Subagent pipeline for Claude Code
One orchestrator that plans and never writes, four workers each on the cheapest tier that does its job, and a reviewer with no Write tool. One paste installs it in every project on your machine.
Get the bundle
Two fields. We send the files and a setup note — that's it.
If this sounds familiar, the claude subagent is for you.
The model that designed your architecture is the one renaming forty variables, and you pay top-tier rates for both.
Your careful brief is still in the window, buried under every draft the same session produced on top of it.
The model that wrote the deliverable is the model you ask whether it's any good. It says yes.
You catch the misunderstanding after the run finishes, at the one moment fixing it costs the entire run.
A working system, not a prompt.
Each piece extracted from a live engine — same prompts, same scaffolding, same rules.
- 01The six-agent architecture — pipeline, Explore, researcher, drafter, bulk and final-review — with the model, the tool list and the job pinned for each, and the reasoning behind every placement
- 02The one-paste install: a single message that writes five agent files and a /pipeline slash command under ~/.claude/, and merges into the two files you already have, so it works in every project on the machine
- 03The six-phase run — load context, plan, gather, execute, final gate, apply — with the single approval gate sitting right after the brief, where a redirect still costs thirty seconds instead of a whole run
- 04The four load-bearing rules: the cheapest model that does it correctly, paths instead of payloads, a reviewer that physically cannot edit, and a brief written as a contract with a real out-of-scope list
- 05The run-folder contract — brief.md, plan.md, research.md, review.md and output/ on disk — so state never travels back through the most expensive context window in the run
- 06A troubleshooting table for the four failures that actually happen: missing spawn depth, agent not found, no stop for approval, and costs going up instead of down
Every rule replaces a request with a structure. Don't ask a model to be brief — take away the context that lets it be long. Don't ask a reviewer not to edit — remove its Write tool.
Built for a specific operator. Not for everyone.
- Claude Code users running long, multi-file jobs who watch a careful brief get buried under forty drafts in the same context window
- Solo operators and small teams paying top-tier rates for mechanical work, who want the typing moved down a tier without losing judgement on the plan
- Anyone shipping client-facing deliverables out of Claude who wants a review step the model that wrote the work cannot quietly overrule
- Anyone expecting an app or a coding agent — this is a configuration pattern: five markdown files, one slash command, and an environment variable
- Quick single-file work. Lookups, typo fixes, renames and config changes cost more through the pipeline than they save
- Anyone on a Claude Code build older than 2.1.239, or unwilling to set a subagent spawn-depth variable in settings.json
How it works
What are Claude Code subagents?
Subagents are separate Claude Code sessions your main session can spawn, each with its own model, its own tool list, and its own empty context window. That last part is what makes them useful — a worker inherits none of your conversation, so it cannot be dragged off course by forty turns of history, and nothing it produces refills the window you are actually working in. Claude Code reads them from markdown files in ~/.claude/agents/, one file per agent, with the model and tools declared in frontmatter. This guide turns that mechanism into a system: six agents, four pinned tiers, and a fixed order they run in.
Claude Code skills vs agents — and where subagents fit
A skill is instructions: a packaged set of steps loaded into whatever session asks for it. A subagent is a separate session: its own model, its own permissions, its own context. They solve different problems and compose well, since a subagent can load a skill. The pipeline uses both. Every worker is a subagent so the model tier and the tool list can be pinned per job, and any of them can load a brand or style skill when the work is client facing. If you are choosing between them, reach for a skill to standardize how something is done, and a subagent to change who does it and what they are allowed to touch.
Running parallel agents in Claude Code without burning budget
Independent tasks go out in a single message so they run at the same time, and that is where the wall-clock saving comes from. The cost saving comes from somewhere else: workers return a file path and three lines, never the draft itself. State lives in a run folder on disk — brief.md, plan.md, research.md, review.md and output/ — so the orchestrator's context holds paths and status, never payloads. That matters because the orchestrator's window is the one that survives the whole run on the most expensive tier, and anything routed back through it is paid for at that rate, then carried again on every remaining turn.
The same claude subagent I run for paying clients. Yours, free.
Two fields. The bundle and a short setup note land in your inbox.
07 · FAQ
Common questions
Do I need to be technical to install it?
No. You paste one message into Claude Code in any directory and it writes the files for you — five agent definitions, a /pipeline command, and two merges into files you already have. The only manual step is restarting your session afterwards, because Claude Code reads agent files at launch and cannot reload them for itself.
Will this actually cost me less?
Only on the right jobs. Every run costs a planning round trip and a frontier-tier context, so trivial work routed through it costs more, not less. The threshold in the guide has four parts — a client-facing deliverable, more than two files, research needed before execution, or an approval step. Below that, stay in the main thread.
What stops the reviewer editing the work itself?
Its tool list. final-review has Read, Grep, Glob and Skill, and no Write. That is enforced by the harness, not by an instruction it was asked to follow. An instruction is a promise a model can break under pressure; a missing tool is a guarantee.
Can I change the models or add my own agents?
Yes, and you should. The tiers in the guide are the ones running here daily, but the frontmatter is two lines per agent — swap a model, add a tool, add a sixth worker. What carries is the architecture: a planner that never writes, workers on the cheapest tier that does the job, and a reviewer that cannot edit.
Want the system built around your work, not ours?
Generative AI consulting starts where this guide stops — mapping your actual workflows, feeding real brand context into them, and shipping orchestration that connects to enquiries and revenue instead of stalling as a pilot.
“I build AI growth engines for luxury villas, boutique hotels, and high-ticket service brands. The skills I give away are the ones I run for paying clients. If you build it yourself, great — if you’d rather have it built and run, talk to me.”