Agent Builder.
The meta-agent that builds all other agents. Takes a description of repeatable work and produces a complete five-file agent package ready to deploy. Output is a folder, not a file. A hard fork sits in Phase 1: before any mapping or generation, the builder asks the human whether to use a human-provided golden example (Mode A) or a builder-drafted one (Mode B). No default — the build waits.
Part A — Agent Manifest
A complete agent folder containing five files. The folder is self-contained — any Claude session can read the START-HERE and run the agent without additional context.
What it produces
01-start-here.html
Three-part entry point: manifest (what it produces, what it needs, how long), agent training (step-by-step process), and human training (your two jobs).
02-golden-example/
A completed, high-quality deliverable showing exactly what “done” looks like. The specification by example. Uses the deliverable’s own design system, not the internal house style.
03-process.html
Machine-readable execution steps. Every decision rule, branch, and output specification the agent follows.
04-context.html
Input manifest listing all required, recommended, and optional data. Domain knowledge tables and reference material.
05-quality.html
QC gates with weighted scoring. Blockers, majors, and minors. Pass criteria the agent checks before delivering.
What it needs
Description of the repeatable work
What does this agent do? What’s the trigger? What does the finished deliverable look like? This can be a conversation, a document, or a working example.
Decision: golden example mode
Before the builder starts mapping, you choose how the golden example gets made. Mode A — you bring it. A real, completed instance of the deliverable. The builder uses it as the spec. Mode B — the builder drafts it. From your description and clarifying answers, the builder writes the example and you validate before the rest of the package is built. There is no default; the builder asks and waits.
Input sources
Where does the data come from? Files, APIs, transcripts, spreadsheets? Knowing the inputs shapes the context file.
Quality criteria
What makes a good output vs a bad one? If not provided, the builder infers quality gates from the golden example.
Estimated time
| Phase | Duration | What happens |
|---|---|---|
| Gather inputs | 10 min | Human assembles source material, examples, and target folder |
| Generate package | 15 min | Agent writes all five files and runs self-QC |
| Review & iterate | 10 min | Human reviews, flags fixes, agent patches |
How to run
- Tell Claude: “Build an agent for [description of repeatable work].”
- Claude reads this START-HERE to understand what the builder does.
- Claude reads the
02-golden-example/folder first — this is the target, the shape of “done.” - Claude reads
03-process.htmlfor execution steps. - Claude reads
04-context.htmlfor input requirements and domain knowledge. - Claude reads
05-quality.htmlfor the QC gates it will check against. - Claude asks the golden example mode question (Step 02b) and waits for your answer.
- Claude then asks “Why is this important?” (Step 02c) and ladders your answer up to the business outcome. This becomes the first section of the new agent’s process — so the agent works toward the real outcome, not just the artifact.
- Claude asks any remaining clarifying questions, then generates all five files in the order set by the chosen mode.
- You review, iterate, and deploy the folder to the appropriate
Agents/subfolder.
Part B — Agent Training
This is how you (Claude) build an agent. Follow these steps in order. The detailed logic lives in 03-process.html — this section is the overview.
Read the 02-golden-example/ folder first.
Identify the repeatable unit, trigger, and definition of done.
Process, context, golden example, quality, START-HERE.
Ask before guessing, then write all five files.
Run blockers from 05-quality.html before handing off.
Study the golden example
Read the 02-golden-example/ folder first. This is a complete, deployed agent — five files that show exactly what “done” looks like. Internalize the structure, the tone, the level of detail. Everything you build aims at this target.
Understand the work
Read whatever the human provides — description, example output, source repo, transcript. Your job is to identify: what is the repeatable unit of work? What triggers it? What does “done” look like?
Ask the golden example mode question
Before mapping or generating anything, ask the human: “Are you bringing me the golden example, or am I building it?” Present both modes with neutral trade-offs. Wait for an answer. Do not assume a default. Record the chosen mode in your reply (“Proceeding in Mode A” / “Proceeding in Mode B”) before continuing. See 03-process.html Step 02b for full wording.
Sort the work into the five files
Sort what you learned into the five files. Every agent has them, even if the source material uses different names: golden example (what done looks like), process (the steps to do the work), context (the inputs and reference data), quality (how you know it’s good), and START-HERE (the entry point).
Ask clarifying questions
If anything is ambiguous or missing — agent name, trigger phrase, folder location, what “good enough” means for the first run — ask the human before generating. Don’t guess on structural decisions.
Generate the five files
Write each internal file against the canonical 0. Chief of Staff/house-style.html. Copy its <style> block verbatim — do not paraphrase. The golden example is the one exception: it uses the deliverable’s own design system, not the house style.
Self-QC before handoff
Run the quality gates from 05-quality.html. Every blocker must pass. No more than two majors remaining.
Three-run graduation
Every agent graduates in three iterations:
- Run 01: Built from golden example. Agent raises its hand for missing context.
- Run 02: Answers get hardwired in. Agent now knows where to find inputs.
- Run 03: Ready for a schedule. Agent runs autonomously.
Part C — Human Training
Your job is to review and iterate. The agent does the work.
Provide source material
Give the agent a description, a repo, or a transcript. The more you give it, the better the output.
Choose the golden example mode
The builder will ask before mapping: are you bringing the golden example, or is the builder drafting it? Mode A makes the build faster and Run 01 sharper, but only works if you have a real, completed instance of the deliverable on hand. Mode B works even when you don’t — the builder drafts and you validate before the rest of the package is built. Pick whichever fits the inputs you actually have.
Review and iterate
Look at the five files the agent produces. If something’s wrong, say so. The agent fixes it. Most packages are 80%+ correct on first pass.
How the system gets better over time
Every time you build an agent and deploy it, the system gets better. Past agents become patterns the builder recognizes. Context files accumulate. The agent builder literally gets better at building agents the more agents exist in the system.
When to build an agent
If you’ve done the same type of work three or more times, it’s an agent. If someone asks you “how do you do X?” and the answer takes more than two sentences, it’s an agent. If you catch yourself saying “just like we did for Y,” it’s an agent.
Files in This Package
Read in this order. The golden example comes first so you know what you’re building toward.
| Order | File | Purpose |
|---|---|---|
| 01 | 01-start-here.html | This file. Manifest, agent training, human training. Read first to orient. |
| 02 | 02-golden-example/ | A complete deployed agent (the presentation agent) showing what the builder should produce. Your target. |
| 03 | 03-process.html | Machine-readable build steps. The detailed logic Claude follows when generating an agent package. |
| 04 | 04-context.html | Input manifest and domain knowledge for the agent builder itself. |
| 05 | 05-quality.html | QC gates for evaluating a completed agent package. Five gates, weighted scoring. |