{"success":true,"course":{"all_concepts_covered":["Repo-embedded harness architecture (skills/commands/hooks)","Durable work artifacts and session disposability","Context-efficiency and tool-based retrieval to control cost","Spawn discipline: parallel workers with isolated context","Role-based governance and tool-permission gating","Exit-state QA loops to prevent infinite churn","Low-cost recovery via nudges and handoffs"],"assembly_rationale":"The course is assembled as an advanced operating model rather than a feature tour, matching the learner’s ZPD and explicit skips. It starts with the architectural control plane (durable repo artifacts and hooks), then teaches the dominant cost driver (context rot) and the main budget lever (tool-based retrieval). Next it shows how to scale throughput without blowing budget by sharding context across parallel workers. Finally it adds the operational layer—role separation, exit-state loops, and handoffs—so many-agent work stays reliable and recoverable day to day.","average_segment_quality":7.33375,"concept_key":"CONCEPT#145be0a2c6a791b64f8e0a5394c77d53","considerations":["The available segments are not GasTown-native demos; treat the course as a transfer-focused operating model and map the patterns onto GasTown’s exact primitives (Beads, convoys, crew/polecats, problems/feed views) using its docs.","If your team’s constraints are dominated by subscription caps and throttles, add a GasTown-specific reference sheet for your plan templates (formulas/molecules) and escalation rules to make the patterns immediately executable."],"course_id":"course_1772084376","created_at":"2026-02-26T05:55:02.332374+00:00","created_by":"Shaunak Ghosh","description":"Build an advanced operating model for using GasTown day to day: treat the repo as the control plane, keep sessions disposable, and scale parallel workers without exploding cost. You’ll learn practical cost/throughput levers (context efficiency, spawn discipline) and the operational loops that keep large multi-agent work reliable.","estimated_total_duration_minutes":30.0,"final_learning_outcomes":["Explain why a repo-embedded harness (skills/commands/hooks) enables GasTown’s durable, restartable workflows.","Diagnose and reduce context rot using smallest-high-signal context and tool-based retrieval.","Design a cost-aware scaling strategy using spawn discipline and context-sharded workers (Polecats) that return distilled results.","Apply role-gated QA loops with clear exit criteria, and recover stalled work via low-cost interventions and handoffs."],"generated_at":"2026-02-26T05:53:55Z","generation_error":null,"generation_progress":100.0,"generation_status":"completed","generation_step":"completed","generation_time_seconds":291.44079661369324,"image_description":"A senior software engineer seated at a clean desk in a modern office, leaning forward with focused attention. In front of them are two monitors angled slightly away from the camera, showing indistinct, blurred code diffs and a blurred status-style view suggesting multiple concurrent tasks, without readable text. On the desk: a mechanical keyboard, a closed notebook with hand-drawn boxes-and-arrows architecture sketches (no legible writing), and a small stack of color-coded index cards representing ‘beads’ or work packets. A coffee mug and a minimal desk lamp add realism. The mood is calm, operational, and high-leverage—like someone actively orchestrating parallel agent work while staying disciplined about cost and reliability.","image_url":"https://course-builder-course-thumbnails.s3.us-east-1.amazonaws.com/courses/course_1772084376/thumbnail.png","interleaved_practice":[{"difficulty":"mastery","correct_option_index":3.0,"question":"You’re near your monthly usage cap, and a long-running Crew session is getting slower and less accurate. You still need three parallel investigations (tests failing, API change, and migration notes). Which approach best preserves throughput while minimizing cost, assuming GasTown persistence (hooks/Beads) is available?","option_explanations":["Incorrect: bigger context often worsens reliability (lost-in-the-middle) and increases cost; it’s the opposite of spawn discipline.","Incorrect: compaction still consumes tokens and time, and a monolithic thread keeps the system in the context-rot regime.","Incorrect: always-on integrations can bloat baseline context/latency; it doesn’t solve the core issue of main-thread overload.","Correct! Sharding into isolated workers plus tool-based retrieval keeps the main thread small and preserves throughput under caps, while Beads/hooks carry durable state across sessions."],"options":["Switch to a larger-context model and keep the workflow monolithic, prioritizing fewer session restarts over context discipline.","Keep everything in one Crew session, repeatedly compacting, and paste full files when needed to avoid losing any details.","Add a heavy always-on integration layer so the main session can fetch everything, even if it increases baseline context on every turn.","Split the work into Polecats/sub-agents with isolated context, force tool-based retrieval (grep/git log), and return only distilled bead summaries to the Mayor/main thread."],"question_id":"q1_spawn_vs_context_bloat","related_micro_concepts":["hooks_beads_architecture","subscription_throughput_budget","meow_convoys_formulas"],"discrimination_explanation":"Polecats/sub-agents with isolated context directly attack the failure mode (context rot) while maintaining parallelism. Tool-based retrieval prevents token bloat, and Beads/hooks provide durable state so the Mayor thread only needs summaries. The other options all keep the main context heavy, which increases cost and degrades retrieval."},{"difficulty":"mastery","correct_option_index":3.0,"question":"A Polecat is editing many small files across a convoy. You want deterministic self-validation that catches errors immediately with minimal rework, and you want the proof to be auditable later. Where should you attach the validator hook in the lifecycle, and why?","option_explanations":["Incorrect: end-only validation increases the blast radius—errors can compound across files before you notice.","Incorrect: periodic validation reduces coupling, but it delays feedback and weakens the deterministic closed loop you want.","Incorrect: pre-tool hooks can enforce policy, but they cannot validate the correctness of edits that haven’t happened yet.","Correct! Post-tool-use hooks validate the specific artifact that just changed, enabling immediate recovery and producing reliable audit logs."],"options":["Only at the very end (stop hook), so validation runs once and saves compute even if earlier steps were wrong.","As a periodic background job, so validation is decoupled from the workflow and doesn’t slow down edits.","Before any tool call (pre-tool-use hook), so you can block the agent from making changes unless it predicts success.","After each tool-use/write (post-tool-use hook), so each touched file is checked immediately and produces per-action logs."],"question_id":"q2_hook_placement_validation_tradeoff","related_micro_concepts":["hooks_beads_architecture","monitoring_recovery_patterns"],"discrimination_explanation":"Post-tool-use validation creates a closed loop: detect → instruct → fix → rerun, while the change is still local and cheap to repair. It also naturally emits auditable artifacts (timestamps/logs) per action. Stop hooks can be too late (batch failure), pre-tool hooks can’t validate reality, and periodic jobs break the tight recovery loop."},{"difficulty":"mastery","correct_option_index":0.0,"question":"A convoy ran overnight and one Polecat is now looping with low-signal retries, but it produced partial progress in Beads/artifacts. You want the lowest-cost recovery that preserves progress while refreshing context. What should you do?","option_explanations":["Correct! Preserve progress in durable artifacts, then refresh context by handing off to a new session that retrieves only what it needs and proceeds under clear termination conditions.","Incorrect: rehydrating everything maximizes token burn and often worsens retrieval; it’s not cost-efficient recovery.","Incorrect: discarding artifacts sacrifices progress; with durable artifacts, you should preserve and continue safely.","Incorrect: more autonomy in the same degraded context typically increases churn and cost; it doesn’t reset the failure mode."],"options":["Commit the partial artifacts and a short state summary, then hand off to a fresh session/agent that retrieves only the needed context (seance-style) from Beads/logs and continues with explicit exit criteria.","Paste the entire repo state and all previous conversation into the same session to ‘remind’ it, then ask it to continue.","Delete the artifacts and rerun from scratch with a stronger model, because partial work is likely contaminated.","Keep the same session running and increase its autonomy, so it eventually explores more options without supervision."],"question_id":"q3_sessions_are_cattle_recovery_choice","related_micro_concepts":["hooks_beads_architecture","subscription_throughput_budget","monitoring_recovery_patterns"],"discrimination_explanation":"‘Sessions are cattle’ means you preserve durable work (Beads/artifacts) but replace exhausted context. A fresh agent can rehydrate only high-signal state via summaries/logs, avoiding context rot and runaway retries. The other options either deepen the loop, inflate context cost, or throw away value."},{"difficulty":"mastery","correct_option_index":3.0,"question":"You need a deep refactor spanning multiple modules with tight cross-file invariants. Budget is constrained, but correctness risk is higher than speed. In GasTown terms, what’s the best operating choice, and why?","option_explanations":["Incorrect: maximum parallelism creates merge and invariant conflicts; reconciliation cost often exceeds the time saved.","Incorrect: removing gates increases rework and cost; the failure is discovered late when it’s most expensive to fix.","Incorrect: ultra-long sessions are prone to context rot and retrieval degradation; they’re rarely the cheapest path to correctness.","Correct! Crew is the right trade-off when shared invariants dominate; hooks and bead-scoping preserve correctness while keeping restarts and cost manageable."],"options":["Spawn as many Polecats as possible to maximize parallelism; let each one edit freely, then reconcile everything at the end in one large PR.","Avoid hooks and gates to save time; rely on human review at the end because the model will be ‘mostly right’.","Run everything in a single ultra-long session so the agent ‘never forgets’ the invariants.","Use a small number of high-context Crew sessions, gated by hooks/standards, and keep work bead-scoped so you can checkpoint and restart without losing invariants."],"question_id":"q4_crew_vs_polecats_deep_refactor","related_micro_concepts":["hooks_beads_architecture","subscription_throughput_budget","meow_convoys_formulas"],"discrimination_explanation":"Deep refactors benefit from shared high-context reasoning, but you still want checkpointable, bead-scoped progress and deterministic gates to prevent expensive regression cycles. A small number of Crew sessions with hooks provides that balance. Swarms and monolithic sessions amplify coordination and context-rot failure modes."},{"difficulty":"mastery","correct_option_index":1.0,"question":"Your team is scaling to many agents generating PRs, and the merge queue is constantly blocked by flaky changes and inconsistent quality. Which pattern best reduces chaos while keeping throughput high?","option_explanations":["Incorrect: mega-PRs increase review/rollback cost and make failures harder to isolate; they reduce true throughput.","Correct! Role separation plus deterministic validation and small PR scope is the reliable way to scale PR volume without blocking the queue.","Incorrect: longer prompts increase context cost and still don’t enforce standards deterministically; they’re a weak substitute for gated loops.","Incorrect: auto-merge turns the merge queue into production risk; it removes the gate exactly where you need it most."],"options":["Move all work into a single large PR per day to reduce the number of merge-queue entries.","Introduce a role-gated loop: workers can propose changes, a QA/witness role validates against an exit-state standard using hooks/log artifacts, and only bead-sized PRs that pass enter the queue.","Increase the system prompt with more rules so each agent ‘remembers’ the standards without needing separate QA roles.","Allow agents to auto-merge to keep velocity high; fix issues later because the queue is the bottleneck."],"question_id":"q5_merge_queue_hygiene_scaling_many_prs","related_micro_concepts":["hooks_beads_architecture","meow_convoys_formulas","monitoring_recovery_patterns"],"discrimination_explanation":"Merge-queue hygiene is an ops problem: you need deterministic gates, small blast radius (bead-sized PRs), and separation of duties so validation is reliable and auditable. Auto-merge and mega-PRs increase risk; prompt-only standards don’t provide enforceable proof or consistent exits."},{"difficulty":"mastery","correct_option_index":0.0,"question":"A Polecat keeps asking you to paste more files to diagnose a regression. You want the cheapest approach that also improves accuracy. What’s the best instruction, consistent with GasTown’s budget/throughput strategy?","option_explanations":["Correct! Use tools to fetch precise evidence, then summarize minimally into durable artifacts so the next session/agent can continue cheaply.","Incorrect: vector-only recall can be brittle for exact error strings, paths, and commits; hybrid retrieval is more robust.","Incorrect: prompt-stuffing maximizes token cost and worsens retrieval; it’s usually the least accurate path at scale.","Incorrect: better models help, but uncontrolled context growth will still waste budget and degrade performance."],"options":["Direct it to use tool-based retrieval first (ripgrep, git log, diffs, targeted reads), then include only the minimal snippets needed for reasoning in its Bead summary.","Force it to rely on embeddings/vector memory only; forbid exact keyword search to reduce ‘overfitting’ to strings.","Paste the full files anyway; tool calls are slower than reading the code in the prompt.","Switch models immediately; regressions are model-quality problems, not workflow problems."],"question_id":"q6_tool_retrieval_vs_prompt_stuffing","related_micro_concepts":["subscription_throughput_budget","meow_convoys_formulas"],"discrimination_explanation":"Tool-based retrieval is the core cost lever: it keeps tokens low and improves precision by finding the exact facts needed (diffs, blame, logs) instead of flooding context. Pure vector recall can miss exact matches, and model-switching doesn’t fix a bad information diet."},{"difficulty":"mastery","correct_option_index":3.0,"question":"In your monitoring loop, you notice an agent repeatedly calling the same tool with tiny variations and not making progress. You want the lowest-cost intervention that preserves work and avoids infinite loops. What do you do first?","option_explanations":["Incorrect: full restart discards value; with durable artifacts you should recover, not reset.","Incorrect: more detail can be useful, but in a looping failure mode it often increases tokens without adding new evidence.","Incorrect: parallelizing a stuck loop multiplies the same failure mode and spend; it rarely fixes root cause.","Correct! A bounded nudge plus role-appropriate handoff preserves artifacts, reduces churn, and prevents runaway cost."],"options":["Immediately start a brand-new convoy from scratch to avoid any contaminated context.","Ask the agent to write a longer plan with more detail, even if it consumes much more context.","Increase parallelism by spawning more agents on the same task until one succeeds.","Send a nudge that adds explicit exit criteria and an iteration cap, and if it still fails, hand off the current artifacts to a fresh agent with a narrower role (e.g., QA/witness) to reassess."],"question_id":"q7_low_cost_interventions_for_stalled_agents","related_micro_concepts":["subscription_throughput_budget","monitoring_recovery_patterns","hooks_beads_architecture"],"discrimination_explanation":"The cheapest recovery is to bound the loop (exit criteria + caps) and refresh context/role only if needed, while preserving durable artifacts. Restarting everything wastes progress, more parallelism amplifies cost, and longer plans often deepen context rot without changing the underlying stall."}],"is_public":true,"key_decisions":["Segment 1 [d33CK8uuji0_1609_1997]: Chosen as the closest high-quality mental model for GasTown’s git-backed hooks + durable artifacts; placed first to establish the repo-as-control-plane architecture before any cost/scaling tactics.","Segment 2 [d33CK8uuji0_2312_2845]: Chosen for strong cost/throughput mechanisms (context rot, smallest-high-signal context, tool-based retrieval); placed second because budget strategy depends on having persistence/harness primitives.","Segment 3 [RFKCzGlAU6Q_1731_2089]: Chosen to operationalize ‘sessions are cattle’ via context sharding and spawn discipline; placed third to turn budget theory into scalable execution patterns (Polecats/convoys analog).","Segment 4 [d33CK8uuji0_2845_3345]: Chosen to cover power-user operations (role governance, QA gates, exit-state loops, handoffs); placed last because monitoring/recovery patterns only make sense after you’re already running parallel workers."],"micro_concepts":[{"prerequisites":[],"learning_outcomes":["Explain how hooks + Beads persistence differs from typical “chat-history” agent tools and why it reduces rework.","Distinguish key roles (Mayor, Crew, Polecats, Witness/Refinery/Deacon) by responsibility and failure mode.","Decide when persistence (hooks/molecules) is the right tool versus a single long interactive session."],"difficulty_level":"advanced","concept_id":"hooks_beads_architecture","name":"Hooks and Beads persistence model","description":"Build a precise mental model of Gas Town’s core architectural difference: durable work state lives in git-backed hooks and Beads, so agents can restart, hand off, and continue without losing the thread.","sequence_order":0.0},{"prerequisites":["hooks_beads_architecture"],"learning_outcomes":["Set explicit throughput targets (parallelism level, turnaround time) that fit within your subscription/API constraints.","Apply “context-efficiency” tactics (handoff strategy, avoiding re-explaining state) to reduce wasted agent cycles.","Choose when to run a small number of high-context Crew sessions vs a swarm of narrowly-scoped Polecats for cheaper iteration."],"difficulty_level":"advanced","concept_id":"subscription_throughput_budget","name":"Cost model: subscriptions, caps, throttles","description":"Translate Gas Town’s runtime choices into a practical cost-and-throughput operating model: how parallelism, context resets, and agent spawning affect real spend and usage caps even when you’re “not paying per token.”","sequence_order":1.0},{"prerequisites":["hooks_beads_architecture","subscription_throughput_budget"],"learning_outcomes":["Decompose a feature into bead-sized work items that Polecats can execute autonomously with minimal back-and-forth.","Use convoys to coordinate parallel work while keeping accountability and rollups intact.","Adopt formulas/molecules for recurring workflows (review, release, audits) so quality improves while prompt overhead shrinks."],"difficulty_level":"advanced","concept_id":"meow_convoys_formulas","name":"MEOW convoys and slinging strategy","description":"Learn the workflow structure that makes Gas Town feel “different day to day”: MEOW-style decomposition into beads, grouping into convoys, and using formulas/molecules to make high-quality work repeatable and trackable.","sequence_order":2.0},{"prerequisites":["hooks_beads_architecture","subscription_throughput_budget","meow_convoys_formulas"],"learning_outcomes":["Run a lightweight triage loop to keep many agents productive without constant supervision.","Diagnose common failure states (stalls, zombies, low-signal loops) and choose the lowest-cost intervention.","Use recovery patterns (handoff, nudges, seance-style context retrieval) to preserve progress while refreshing context."],"difficulty_level":"advanced","concept_id":"monitoring_recovery_patterns","name":"Feed, problems view, recovery loops","description":"Adopt power-user operations patterns that prevent burn: monitoring at scale, detecting stuck agents early, and using recovery tools (nudge/handoff/seance) so work keeps moving under GUPP/NDI instead of stalling.","sequence_order":3.0}],"overall_coherence_score":8.4,"pedagogical_soundness_score":8.1,"prerequisites":["Daily comfort using LLM coding agents in real repos","Strong Git fluency (branches, diffs, PR-based workflow)","Practical intuition for LLM context limits and tool-calling","Experience delegating work across multiple parallel workstreams"],"rejected_segments_rationale":"Most available segments were rejected because they (a) are not GasTown-specific and add low incremental value beyond the selected mechanisms, (b) are setup/configuration/command-tour adjacent (disallowed for advanced), (c) are redundant with already-selected primary outcomes (multiple segments repeating generic context-window hygiene or agent/workflow definitions), or (d) are entirely irrelevant to the learner’s goal (e.g., Formula 1 regulations, bodybuilding pharmacology). Some relevant-but-lower-quality segments (e.g., subscription/local-model cost framing) were excluded to stay under the 30-minute budget and preserve a single, non-redundant primary learning outcome per segment.","segment_thumbnail_urls":["https://i.ytimg.com/vi_webp/d33CK8uuji0/maxresdefault.webp","https://i.ytimg.com/vi_webp/RFKCzGlAU6Q/maxresdefault.webp"],"segments":[{"before_you_start":"You already know how to ship code with agents and Git. GasTown changes the game when workflow control is durable, repo-backed, and enforceable, via hooks and persistent artifacts like Beads. This segment builds the mental model of layered harness pieces, so restarts and handoffs don’t mean rework.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1772084376/segments/d33CK8uuji0_1609_1997/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["Harness as a repo-embedded control plane for agents","Evidence-based delivery via standards/definition-of-done","Skills vs commands (just-in-time process vs explicit workflows)","Context bloat/rot as a driver for modularization","YAML front matter/metadata as skill routing mechanism","Using skills to encapsulate repetitive SOP-like work"],"duration_seconds":388.1200000000001,"learning_outcomes":["Explain why harnesses (skills/commands/hooks) are an architectural shift from single-chat prompting","Distinguish skills (just-in-time procedures) from commands (explicit multi-step workflows) and why that matters for cost and reliability","Design a ‘definition of done’/standards layer that agents must satisfy before output is accepted","Identify when a large knowledge base should be refactored into modular skills to reduce context rot"],"micro_concept_id":"hooks_beads_architecture","prerequisites":["Comfort using LLM coding agents in a repo/workspace","Working knowledge of Git-based workflows","Basic familiarity with prompts vs. structured workflows"],"quality_score":7.255,"segment_id":"d33CK8uuji0_1609_1997","sequence_number":1.0,"title":"Repo Control Plane: Skills and Hooks","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"","overall_transition_score":10.0,"to_segment_id":"d33CK8uuji0_1609_1997","pedagogical_progression_score":10.0,"vocabulary_consistency_score":10.0,"knowledge_building_score":10.0,"transition_explanation":"N/A (course start)"},"url":"https://www.youtube.com/watch?v=d33CK8uuji0&t=1609s","video_duration_seconds":4817.0},{"before_you_start":"Now that you have a durable control plane, the next bottleneck is spend and throughput. Long sessions quietly inflate cost through context rot, restating, and low-signal token bloat. This segment shows how to stay under caps by feeding the smallest high-signal context, and using tools to fetch facts on demand.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1772084376/segments/d33CK8uuji0_2312_2845/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["Context rot compounding across multi-turn work","Token economics: input tokens ballooning for small outputs","Context engineering principle: smallest high-signal token set","Tool-based retrieval (grep/search/history/commits) vs loading context","Using IDE/LSP semantic navigation to reduce agent cognitive load","Avoiding MCP context bloat; prefer CLI tools (e.g., GitHub CLI)"],"duration_seconds":532.98,"learning_outcomes":["Diagnose context rot as a token and reliability problem in long-running agent work","Apply a ‘smallest high-signal tokens’ discipline to prompts, artifacts, and workflow design","Replace context stuffing with tool-based retrieval patterns (search, commit history, session IDs)","Choose integration strategies that minimize context load (CLI/LSP over MCP when possible)"],"micro_concept_id":"subscription_throughput_budget","prerequisites":["Strong CLI fluency (grep/ripgrep, head, basic scripting)","Familiarity with IDE navigation and language servers (LSP)","Understanding of context window/token limits in agent systems"],"quality_score":7.665,"segment_id":"d33CK8uuji0_2312_2845","sequence_number":2.0,"title":"Context Rot: The Hidden Cost Driver","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"d33CK8uuji0_1609_1997","overall_transition_score":8.6,"to_segment_id":"d33CK8uuji0_2312_2845","pedagogical_progression_score":8.5,"vocabulary_consistency_score":8.0,"knowledge_building_score":9.0,"transition_explanation":"Builds on the repo-as-control-plane idea by showing how durable artifacts let you avoid rehydrating state into expensive context, turning persistence into a direct budget lever."},"url":"https://www.youtube.com/watch?v=d33CK8uuji0&t=2312s","video_duration_seconds":4817.0},{"before_you_start":"With context-efficiency in place, you can safely scale output. GasTown’s MEOW decomposition works when tasks are bead-sized, and convoys are just parallel lanes with clear rollups. This segment teaches the key pattern: spawn specialized Polecats with isolated context, then merge back only results so your main session stays fast and cheap.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1772084376/segments/RFKCzGlAU6Q_1731_2089/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["Sub-agents as context isolation/sharding","Returning only results to avoid context bloat","Task tool-call interface (description + prompt)","Parallelizable agent workstreams","Agents prompting other agents (recursive delegation)"],"duration_seconds":358.001,"learning_outcomes":["Design sub-agent/task patterns that keep the main agent context small and high-signal","Structure delegations using a ‘description + prompt’ interface and return-only-results discipline","Identify which work should be offloaded to specialized workers to improve throughput/cost"],"micro_concept_id":"meow_convoys_formulas","prerequisites":["Understanding of LLM context windows and degradation with long chats","Experience running parallel investigative tasks on codebases"],"quality_score":7.0,"segment_id":"RFKCzGlAU6Q_1731_2089","sequence_number":3.0,"title":"Spawn Discipline: Shard Context with Polecats","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"d33CK8uuji0_2312_2845","overall_transition_score":8.4,"to_segment_id":"RFKCzGlAU6Q_1731_2089","pedagogical_progression_score":8.5,"vocabulary_consistency_score":8.5,"knowledge_building_score":8.5,"transition_explanation":"Moves from ‘minimize context’ to ‘use parallel workers to keep context small,’ turning budget discipline into a repeatable scaling tactic."},"url":"https://www.youtube.com/watch?v=RFKCzGlAU6Q&t=1731s","video_duration_seconds":3942.0},{"before_you_start":"Once you’re running convoys of workers, the real skill is operations, not prompting. GasTown’s roles map cleanly to this idea: workers execute, witnesses/QA verify, and the manager coordinates. This segment gives you exit-state loops and handoff patterns, so stuck agents get nudged or replaced, without burning budget.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1772084376/segments/d33CK8uuji0_2845_3345/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["Defense-in-depth via role-based tool permissions","Separating worker roles (coding vs QA/reporting) by restricting tools","Pre- and post-tool hooks as enforcement points for standards","Quality assurance as staged inspection (factory analogy)","Exit-state loops: iterate until standard met, avoid infinite loops","Handoff to another agent with its own context window (session isolation)"],"duration_seconds":499.34000000000015,"learning_outcomes":["Design role-separated agent teams (e.g., builder vs QA) that reduce errors and risky actions","Implement hook-based gates (pre/post tool-use or pre-commit) to enforce standards automatically","Define exit conditions and escalation policies to prevent infinite agent loops","Use handoffs to reset context and keep long-running work moving without chaos"],"micro_concept_id":"monitoring_recovery_patterns","prerequisites":["Experience with multi-agent workflows and task decomposition","Understanding of software QA gates and CI/validation concepts","Basic familiarity with tool permissions/separation of duties"],"quality_score":7.415,"segment_id":"d33CK8uuji0_2845_3345","sequence_number":4.0,"title":"Role-Gated Loops and Low-Cost Recovery","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"RFKCzGlAU6Q_1731_2089","overall_transition_score":8.3,"to_segment_id":"d33CK8uuji0_2845_3345","pedagogical_progression_score":8.0,"vocabulary_consistency_score":8.0,"knowledge_building_score":8.5,"transition_explanation":"Extends parallel execution with the missing control layer: governance, monitoring signals, and recovery loops that keep many workers productive without compounding cost."},"url":"https://www.youtube.com/watch?v=d33CK8uuji0&t=2845s","video_duration_seconds":4817.0}],"selection_strategy":"Select one self-contained, high-density segment per micro-concept, prioritizing depth≥7 and direct transfer to GasTown’s stated differentiators (repo-embedded control plane, context-efficiency, spawn discipline, and role-governed recovery). Arrange segments to build an operating model first (durable hooks/persistence), then budget mechanics (context rot), then scalable execution (sub-agents/Polecats analog), and finally operations (role-gated loops + handoffs).","strengths":["Meets the 30-minute constraint while still covering all four target micro-concepts.","Mechanism-first: emphasizes causal levers (persistence, context economics, isolation, gating) over UI steps.","Strong anti-redundancy: each segment adds a distinct operational capability.","Professional framing: scenarios map naturally to real repo work, PR hygiene, and multi-agent coordination."],"target_difficulty":"advanced","title":"The GasTown Workflows That Save Money","tradeoffs":[],"updated_at":"2026-03-05T08:40:09.881808+00:00","user_id":"google_109800265000582445084"}}