Retired system (July 2026). GSD, the methodology this artifact documents, was retired on 2026-07-06 in favor of a lighter unit of execution: a loop with a goal, a deterministic gate, an iteration budget, and a receipt. The /gsd:* commands no longer exist. This artifact stays published as a record of the system that built this site. The full story: Why I retired the system I documented.

GSD Narration Script: Human-in-the-Loop Infrastructure

This is the narration script for a four-minute explainer video on GSD's Human-in-the-Loop (HIL) infrastructure. The video targets developers and technical leaders evaluating AI-assisted development approaches. Format: five acts with supporting diagram references, paced for short-form technical content.

Act 1: The Problem (45 seconds)

You give an AI a coding task. It starts strong. But three hours later, you're staring at spaghetti code, half-finished features, and an agent that forgot what it was building.

This is the reality of AI coding without structure. The AI loses context. It forgets earlier decisions. It completes tasks but misses the actual goal. And when something breaks, there's no clear path back.

The problem isn't the AI's capability. It's the lack of orchestration. Without a framework to maintain focus, verify outcomes, and keep humans in the loop, even the most capable AI becomes unreliable.

Act 2: The Solution (60 seconds)

Human-in-the-Loop infrastructure is the answer. It's an orchestration layer that transforms chaotic AI coding sessions into production-grade software delivery.

HIL doesn't replace the AI. It guides it. Think of it as a project manager for your coding agents - one that never sleeps, never forgets, and always verifies the work actually got done.

The system has three core layers. First, commands that you invoke to start projects, plan phases, and execute work. Second, specialized agents - a Planner that breaks down goals, an Executor that writes code, and a Verifier that confirms the results actually work. Third, state management that tracks every decision, every file changed, and every checkpoint reached.

The magic is in how these layers work together. The human stays in control. The AI stays focused. And the code actually ships.

Act 3: How It Works (90 seconds)

Here's the HIL workflow in action.

You start with a goal: "Users can send and receive messages." The Planner Agent works backward from that goal. What must be true for this to work? Users see messages. Users can send messages. Messages persist. These become your must-haves.

From those must-haves, the Planner derives the specific artifacts needed - a Chat component, an API endpoint, a database model. Then it decomposes everything into atomic tasks, each one small enough to complete without losing context.

Tasks get organized into waves. Independent work runs in parallel. Dependent work waits its turn. Each task produces an atomic commit - one feature, one commit, fully reversible.

After execution, the Verifier Agent kicks in. It doesn't just check if tasks are done. It checks if the goal is achieved. Does the file exist? Is it real code or just stubs? Is it actually wired into the application?

If verification finds gaps, the system creates targeted fix plans. Execute again. Verify again. Loop until the goal is truly met.

And throughout all of this, checkpoints pause for human review. The AI proposes. You approve. That's what Human-in-the-Loop means.

Act 4: The Skill Ecosystem (45 seconds)

HIL infrastructure isn't just about coding. It's extensible through skills - composable capabilities that agents can invoke.

Skills follow a three-tier loading pattern. Metadata loads first - just enough to know what the skill does. Instructions load when triggered. Deep references load only when needed. This keeps context tight while making specialized knowledge available.

The ecosystem includes skills for documentation generation, Excel automation, data visualization, and even building new skills. Each skill can be used standalone or orchestrated together.

Want to document a codebase, generate a video script, and render an explainer video? Chain the skills. The HIL harness keeps everything coordinated.

Act 5: Call to Action (30 seconds)

This is what autonomous coding looks like when humans stay in control.

The HIL harness transforms AI from an unpredictable assistant into a reliable teammate. Goals get achieved. Code gets verified. Decisions get documented. And you remain the final authority on what ships.

The infrastructure is available now. The agents are ready. The only question is: what will you build?

Production Notes

Target duration: 4:00 Word count: ~660 words Pacing: 150 words/minute (conversational technical pace)

Diagram sequence:

• Acts 1-2: system-overview.mmd (static overview, then animated component highlights)
• Act 3: agent-orchestration.mmd (sequence animation showing plan-execute-verify flow)
• Act 4: skill-structure.mmd (component highlight showing three-tier loading)
• Act 5: harness-integration.mmd (full view showing all components connected)

Tone: Confident but not salesy. Technical enough to earn developer trust, accessible enough for technical leadership. Lead with the problem, not the solution.

Related

For the agent that plans the work described in Act 3, see GSD Planner Agent.

For the verification methodology referenced in Act 3, see GSD Verifier Agent.

For the GSD Tutorial that covers the full methodology in deeper detail, see GSD Tutorial Script.