Agent That Builds Agents.

How this fits in the OS.

Watch for the shape.

One sentence in. A working agent out. Source, compile, store, ping, schedule. That sequence is what /build produces every time, regardless of what the agent is for. Morning Brief is one instance. Weekly summary is another. Lead-reply drafter is another. The instances differ in which sources, which compile step, which delivery channel, which cron. The shape is the same.

This is the capstone behind the capstone. The Morning Brief teaches you the pattern by walking you through one concrete instance. This card teaches you the agent that produces the instance.

What you'll build.

By the end of this card, you have three things on your computer:

• A working /build skill wired in configs/commands/build.md, callable from any session in your workshop repo.
• A worked example. One agent you wanted built, built by /build end to end, deployed via the Ship Anything Autonomous pattern, and scheduled on a cron. The agent answers a real problem you actually had.
• A second-brain entry. The architecture decision /build made, logged to your knowledge base so the next run of /build can find what already worked.

What changes for you.

The artifact is not the point. The shift is what changes when you no longer have to scope a new agent build from scratch. Three things, in order of how soon you feel them:

• You stop saving up agent ideas. The friction was always the build, not the idea. With /build on your computer, an idea you had on a walk becomes a deployed agent before dinner.
• You stop treating agents as one-off projects. The first one feels like a project. The third one feels like a request. The tenth one feels like typing a sentence.
• You start composing instead of building. New agents borrow shapes from the agents /build already made. Sources get reused. Delivery channels get reused. Cron entries get reused. The library of working pieces grows every time you run it.

This is the moment the workshop stops being a class about agents and starts being an agent factory.

Before you start.

The build.

Six steps, mapped one-to-one to the /build skill's own internal steps. The skill drives. You confirm between checkpoints. Resist the urge to skip the manual test, that is the step that distinguishes a working agent from a demo.

The pattern you just shipped.

You did not just ship one agent. You shipped the agent shape that produces every other Stage 06 agent. /build is the generic blueprint executor. Every specific blueprint, Morning Brief, Triple-Model Bid Prep, Calendar Conflict Defender, is a particular use of the same skill.

This is also the moment the workshop's two threads converge. The build thread (one concrete agent, shipped) and the composition thread (sub-agents, agent teams, parallel runs) meet here. /build uses sub-agents to research the shape, compose the pieces, and triangulate when the stakes are high. The composition primitives from Sub-Agents and Building Agent Teams are the engine inside /build.

When it works.

You'll know the meta-capstone is real when four things happen, in order, the first time you run /build on a problem you hadn't pre-scoped:

1. The skill asks only the questions it needs. Not a wall of preference questions. Three or four targeted hard-blockers, scoped to your sentence.
2. The Build Plan you approve in Step 05 is the plan that runs. No scope creep mid-execution. If /build wants to add something, it pauses and asks first.
3. The manual test in Step 06 passes on the first or second try. Not the tenth. If you're on the tenth, the sentence was too vague or the sources weren't actually wired. Cut scope and rerun.
4. You run a second one within a week. The second build is the test. The first one could be enthusiasm. The second one is the flywheel. When the second sentence becomes a working agent in an afternoon, the meta-capstone is real.

Three working agents from /build within a month is the signal that the shape has compounded. After that, you stop counting.

If you get stuck.

Common failure modes, ranked by how often they bite people the first time through:

• The one sentence is too vague. "Help me with email." That is not a problem, it is a wish. /build will ask clarifying questions forever, you'll get frustrated, and the build will stall. Cut the sentence to one specific event, one specific source, one specific landing place. Then rerun.
• Scope creep during execution. You approve a Build Plan with three sources, then ask Claude mid-build to "also add Slack and also wire Notion." The skill will try, the build will balloon, and the manual test will fail because too much got wired at once. Hold scope. Add the next source in a second /build pass.
• Missing MCP for the source you named. You asked for Gmail and Calendar, but the Gmail MCP isn't wired (Claude Desktop calls these connectors). The compile step returns empty. Jump back to Stage 02, wire the connector, then rerun the manual test before the schedule.
• Skipping the manual test. The skill refuses to schedule before the manual test passes. If you try to push past it, you'll get the cron wired to a broken compile step, and tomorrow morning the agent fires silently into nothing. Do the manual test. Always.
• Real keys offered to the chat. If the skill ever offers to type a real API key on your behalf, say no every time. The pattern is placeholder in chat, real value in your password manager. There is no exception worth making this call on.
• The agent the skill built is too narrow to reuse. A feature, not a bug. The first run is one shape. The second run reuses pieces. By the third, the library is paying you back. Don't over-engineer the first one.

Still stuck? Hand the failing transcript and the exact sentence you used to a research sub-agent. Most stalls come from a vague sentence or a missing connector, and a research pass surfaces both faster than another manual retry.

Where to go next.

The meta-capstone is the apex of Stage 06. From here you go in three directions: see the worked instance, generalize the deployment pattern, or take the agent factory into the real business.