Build Process.
Machine-readable execution steps for building an agent package. Follow in order. Each step has decision rules for branching. Orient first, intake, map, generate, deliver.
Phase 0 — Orientation
Before you look at the human’s source material, study the golden example. You need to know what “done” looks like before you start building.
Study the golden example
Read every file in the 02-golden-example/ folder. This is a complete, deployed agent — the presentation agent. It shows the exact output shape, level of detail, tone, and structure you’re aiming at.
What to internalize: how the START-HERE orients the reader, how the process file structures steps, how the context file organizes inputs and reference tables, how the quality file defines gates and scoring, and how the golden example within the example agent demonstrates a real deliverable. This is your target. When in doubt about structure, detail, or format — look at the golden example.
Phase 1 — Intake
Understand what the human wants to automate. The goal is to leave this phase with a clear picture of the repeatable work, an explicit choice on golden example mode (Step 02b is a hard fork — Phase 2 cannot start until the human has chosen), and a captured Why (Step 02c — why this is important, laddered up to the business outcome).
Receive the source material
The human provides one or more of: a description of the work, a completed example, a GitHub repo, a transcript, a document, or a working tool. Read everything provided.
If source is a GitHub repo: fetch the README, file tree, and key files (entry point, config, modes/commands). Identify the implicit pieces — most repos already have process, context, and examples under different names. If source is a transcript or conversation: extract the repeatable pattern. What did the human do? What were the inputs? What was the output? If source is a completed deliverable: this IS the golden example. Reverse-engineer the process from the output.
Identify the repeatable unit
Name the agent. Define the trigger phrase. Answer three questions: what triggers this work? (a phrase, an event, a schedule, an incoming file), what does “done” look like? (one file, multiple files, an action taken), and how often does this run? (daily, weekly, per-event, on-demand).
Choose the golden example mode
Before any mapping or generation, ask the human this question and wait for an answer: “Are you bringing me the golden example, or am I building it? Mode A: you provide a real, completed instance of the deliverable, and I treat it as the spec. Mode B: I draft the golden example from your description and clarifying answers, and you validate before I build the rest.”
Present both options with neutral trade-offs. Do not recommend one over the other. Do not assume a default based on what the human has or hasn’t already provided. The build does not proceed to Phase 2 until the human has explicitly chosen a mode.
Once chosen, record the mode plainly in your reply (“Proceeding in Mode A” or “Proceeding in Mode B”) so the choice is visible in the session log. The mode determines the order of work in Phase 3 — see Step 06.
Ask why this is important
The moment the mode is chosen, before any mapping or generation, ask the human one question: “Tell me — why is this important? What’s it really for?” Then keep asking why until the answer reaches a business outcome, not a restated task.
Ladder it. The deliverable serves a near outcome, which serves a business result, which ladders up to the OGSM. Example: a blog article → builds credibility and gets saved and shared → readers become clients and speaking invitations → revenue and growth. Do not accept “to grow the business” and stop — that is fluff and steers nothing. A one-line answer that just restates the task is not a Why. Keep laddering until the real business outcome is named.
Why this step exists. We do not hand an agent a folder that says “do this thing.” We hand it a folder that says “do this thing, and here is what it is really for” — so the agent does the work in a way that gets the outcome we actually want, instead of just producing the artifact. The agent that knows the blog is for credibility and clients writes a different blog than the agent that only knows “write a blog.”
Capture the laddered answer. You will write it as the opening section of the new agent’s process file — section 00, “Why is this important?” — in Step 07.
Classify the complexity
Determine whether this is a workflow (2 files) or a full agent (5 files). Workflow (process + golden example only): human is the QC layer. Good for work that runs less than weekly. Agent (all 5 files): agent handles QC. Good for frequent work with consistent output shape. Default to agent. It’s trivially more work upfront and dramatically more valuable over time.
Phase 2 — Sorting
Sort the source material into the five-file structure. Every agent has these five files — the source material just calls them different things.
Sort the work into the five files
For each file, identify where the information lives in the source material: process → step-by-step instructions, mode files, runbooks, SOPs, README “usage” sections. Context → config files, environment variables, profile data, reference tables, domain knowledge. Golden example → sample outputs, completed deliverables, example files, templates with real data. Quality → scoring rubrics, test suites, validation rules, “good vs bad” criteria, linting rules. START-HERE → README, getting-started guide, onboarding docs.
If one of the five files has no material in the source: flag it. Ask the human for the missing piece. If they can’t provide it, generate a best-guess draft and ask them to confirm. If the source has more than five pieces: merge. Multiple process docs become one. Multiple config files become one context file.
Ask clarifying questions
If anything is ambiguous or missing, ask the human before proceeding. Do not guess on structural decisions. Common clarifying questions: agent name, trigger phrase, where it lives in the folder structure, who the intended operator is, what “good enough” means for the first run.
Phase 3 — Generation
Write the five files. Use the canonical house style (0. Chief of Staff/house-style.html) for every internal file. The golden example is the one exception — it uses the deliverable’s own design system. Generate in this order.
Write first. Everything else derives from it.
Voice-driven agents: interview the human before drafting. No composites.
Opens with “Why is this important?”, then numbered steps with decision rules.
List every input, categorized as required, recommended, or optional.
Define five gates with blockers, majors, and minors.
Write last — references all other files.
Produce the golden example first
The golden example is the specification. Everything else is derived from it. Execute the mode chosen in Step 02b:
Mode A — Human-provided. Take the example the human supplied. Confirm the format and any conventions (filename, structure, tone). Save it as 02-golden-example.html (or as a folder for meta-agents). Do not modify the substance; treat it as the spec the rest of the package serves.
Mode B — Builder-drafted. Draft the golden example from the human’s description, source material, and clarifying answers. Then stop and present the draft for human validation before continuing to Step 07. Do not write process, context, quality, or START-HERE until the human has signed off on the example. The whole package depends on it. IMPORTANT: if the agent is voice-driven (see Step 06a), do NOT draft in Mode B until Step 06a's interview is complete.
Format rule: the golden example uses the deliverable’s format, not the agent format. If the agent produces newsletters, the golden example is a newsletter. If it produces evaluation reports, the golden example is an evaluation report.
Mine real material first (voice-driven agents only)
This step is required for any agent whose deliverable depends on real customer voice, lived experience, or specific moments. Includes (non-exhaustive): LinkedIn copywriter, viral copywriter, sales emails, case studies, testimonials, customer-voice landing pages, content built from session insights, anything written in first-person from a buyer’s perspective. If the deliverable could be written by anyone in the category without real customer source material, skip this step. If the deliverable lives or dies on whether it sounds like a real human said it, this step is non-negotiable.
Composites are banned. Do not draft the golden example from inferred avatars, demographic profiles, or pattern-matched plausibility. Do not pull "what a Builder would say" or "what an Operator feels" from 00-context/customer.html as if it were source material. customer.html describes buyers in the abstract. It is INPUT for offer design, not voice for copy. Using it as voice source material produces drafts with the SHAPE of the methodology but no real moment underneath — the exact failure mode every voice-driven agent’s first principle warns against.
Interview the human first. Before drafting anything in Mode B, ask focused interview questions to extract three things:
- One real person. Named. Someone the human has actually spoken with (ideally in the last 90 days). Not an avatar, not a category.
- One specific scene. Where they are, what time of day, who else is around, what they just did, what their hands are doing. Get texture down to the mundane.
- One first-person sentence in the person’s own voice. The thing they would say to a friend who actually listens. Not the human’s interpretive translation. The person’s actual words (or the closest the human can recall).
Ask the questions in plain text, not multiple-choice. The answers cannot be selected from a menu — they have to be mined. Use any format the human prefers (voice-typed ramble, bullets, one-word answers, full prose). The dumber the detail, the better the material.
Then draft the golden example from THAT material. Use the actual person, the actual scene, the actual sentence. The draft is a transcription of real material, not an invention. Only after the interview is complete and the draft is built from real answers does the build proceed to Step 06 validation and then Step 07.
Logged failure that produced this gate: 2026-05-27 (see 00-chief-of-staff/decisions.html). Rocky drafted three composite-avatar hooks for @linkedin-copywriter using customer.html profiles as if they were customer voice. Natalee rejected the drafts: "no these don’t sound like me, try again, interview me for insights." This step exists so that failure cannot recur on the next voice-driven agent build.
Write the process file
Open every agent’s process with its Why. The first section of the new agent’s process file is always 00 — Why is this important?, written before step one. Populate it with the laddered answer captured in Step 02c: the deliverable, the near outcome it serves, the business result, and the OGSM goal it ladders to. The agent reads this section first, every run, so it does the work in a way that gets the real outcome — not just the artifact. It must be a real laddered reason, never blank and never a restated task.
Then translate the workflow into numbered steps with decision rules. Each step must answer: what do I read, what do I do with it, and what do I produce? Include branching logic for edge cases.
Process file test: a Claude session with no prior context should be able to read the process file and execute the agent. If it can’t, the process file is incomplete.
Write the context file
List every input the agent needs, categorized as required, recommended, or optional. Include domain knowledge tables, reference data, and any static information the agent uses across runs.
Write the quality file
Define five quality gates. Each gate has blockers (must pass), majors (partial credit), and minors (bonus). Weight the gates: completeness and accuracy matter most.
Default gate structure: Gate 1 — Completeness (25%), Gate 2 — Accuracy (25%), Gate 3 — Format (20%), Gate 4 — Voice & Tone (15%), Gate 5 — Actionability (15%).
Write the START-HERE file
Write last because it references all other files. Two parts: manifest (what it produces, needs, time, how to run) and agent training (step-by-step process overview). Link to every other file in the package.
Phase 4 — Delivery
Self-QC, save, and hand off to the human. Every file path gets stated explicitly so the human can open the output directly.
Self-QC
Run the quality gates from 05-quality.html against your own output. Every blocker must pass. Document any majors that remain and flag them for the human.
Save and report
Save all five files to the target folder. State every file path. Present a summary: agent name, trigger phrase, any open questions, and suggested folder location in the value chain.
Folder location rule: the agent goes in the Agents/ subfolder of the functional area it serves. A marketing agent goes in 3. Marketing/3. Agents/. An operations agent goes in 5. Operations/Agents/. Cross-functional agents go in the primary area they serve.
Suggest next steps
Recommend whether to: run the agent immediately (Run 1), add context files to improve accuracy, register the agent in the Chief of Staff agent directory, or schedule the agent for autonomous execution.