I counted the other day. My Claude Code setup has 37 skills, a multi-agent SDLC pipeline, a six-agent research workflow, a handful of bespoke reviewers, and a knowledge-graph search across nearly 5,000 vault notes. Of all of that, I wrote exactly one thing by hand.
Everything else the system built for itself, with me reviewing every definition and holding the taste gate. The seed was an agent-creator skill. What I want to write about is the bootstrap order — how you go from one hand-written skill to a working agent fleet without ever sitting down to write the fleet.
The three pillars
The setup rests on three structural pillars, and a bootstrap loop stitches them together.
flowchart TD S[Hand-written seed: agent-creator] --> L{Bootstrap loop} L --> RAG[RAG — vault + kg search] L --> VER[Verification — author ≠ reviewer] L --> REC[Recursive improvement — agents improve agents] RAG & VER & REC --> L L --> Fleet[Working agent fleet]
RAG is retrieval-augmented context, broadly defined. The Obsidian vault is long-term memory — research notes, style guides, postmortems, plans — and a kg:search skill puts a knowledge graph in front of it so an agent asks for “notes adjacent to X” instead of grepping blind. Handoff documents in /tmp/claude/handoffs/ let agents talk to each other without sharing a context window.
Verification means every output gets checked by an independent agent before it ships. Code goes through up to six specialist reviewers plus a mutation pass in the SDLC pipeline; research notes go through copy-editor, validate, and conditional fact-check in the research pipeline. The author and the reviewer are never the same agent, and the reviewer never wrote the prompt the author worked from. That separation is load-bearing: it’s how you avoid the failure mode where self-critique only catches typos.
Recursive improvement is agents improving other agents — the agent-creator builds the research agent, whose findings feed back to sharpen the agent-creator’s own definition. Each cycle the seed gets sharper, as long as a human taste gate and a written style guide hold the line. Take either away and the same loop compounds toward mediocrity.
The pillars depend on each other: RAG without verification produces confident wrong notes; verification without RAG burns tokens re-reading context. But that describes the finished system, not how it gets built. Early on, the loop leans on cruder stand-ins — a file on disk for memory, a human reading every output — not the finished pillars, just their scaffolding.
The bootstrap order
You don’t write the whole thing top-down. You build the seed agents that build everything else.
- Hand-write an agent-creator skill. Something that produces well-structured agent definitions given a goal, a style guide, and a tool scope. Even a crude one — three paragraphs of intake, a frontmatter template, a section enforcing your conventions. This is the only thing you write from scratch.
- Use it to create a research agent. A skill that fetches sources, tiers them by credibility, and synthesizes a note. The first version is monolithic — one agent doing all six jobs badly — and that’s fine. It works well enough to build on.
- Point the research agent at itself. “Research best practices for agent creation.” The output is a vault note with sources and concrete claims — specialist vs generalist prompts, handoff formats, which jobs need Opus and which ride on Sonnet. It isn’t great yet, but the claims are usable.
- Feed the research back through the agent-creator. Now it has source material on what good definitions look like. Its prompt and reference files get rewritten against the findings, and the next agent it produces is better than the last, in a direction you can name.
- Point the improved agent-creator at the research agent. Same loop, opposite direction. The research agent gets split into a crawler, a synthesizer, a copy-editor, a validator, and a fact-checker — five agents instead of one. The notes improve immediately, because the agents no longer compete inside a single prompt.
- Have the research agent research its own genre. “Best practices for research workflows.” This is the second-order step, and the findings differ from the agent-creation ones — different failure modes, different separation-of-concerns lessons.
- Iterate. Each cycle, pick the agent that hurts most and run the loop against it. After half a dozen cycles you have a base camp from which every other agent — reviewers, validators, fact-checkers, devops, retro — gets built.
The first cycle is slowest because the seed is dumb. By the fourth or fifth, the marginal cost of a new specialist is an hour of your attention and some tokens.
Why the order matters
Step 1 is the only step you write by hand; everything after is the system improving itself, gated by your taste. Hand-writing agents is expensive and refining generated ones is cheap. A 500-line agent definition with reference files, tool scoping, and a thought-out scope boundary is a half-day of work; running the agent-creator over a brief and refining its output is twenty minutes. Once the seed works, every additional agent costs an order of magnitude less.
The taste gate is the part that doesn’t collapse. You still read every definition, and you reject the ones where the scope drifted or the agent took on a second job. The seed hit that failure mode itself: the agent-creator started out scaffolding definitions and writing their prose, competing with itself across both — the same way the monolithic research agent did before it was split.
Handing the prose to a dedicated authoring specialist left the agent-creator doing one job, structure, and doing it well. But notice what fixed it. I read the output, recognized the split, and rewrote the definition to enforce it. The loop didn’t catch its own over-scoping; the taste gate did.
That rewriting does real causal work; it’s much of what makes the next iteration better. The loop doesn’t buy you freedom from judgment — it buys you freedom from typing. The hours saved on mechanical authoring go into the parts where you add value: scope boundaries, voice calibration, deciding which jobs collapse together and which split apart.
Each step also needs the previous one to exist — you can’t point the research agent at itself before it exists, or improve the agent-creator with findings before there are findings. The loop has a critical path; start anywhere but step 1 and you end up writing agents by hand anyway.
The costs
The loop isn’t free.
The token cost is real and ongoing. A single loop runs between a Sonnet hour and an Opus hour, depending on which models you’ve pinned where, and the recursive part is the most expensive because it runs the full pipeline twice. You notice it on the bill.
Drift is constant pressure. Every cycle it gets better at the conventions it knows and more confident about ones you never asked for. Without an explicit voice profile, its prose slides toward generic LLM register — the register the copy editor exists to flag. The fix: a written style guide it reads on every run, banned-word lists, examples of your own voice.
The curation burden grows with the fleet. Every definition has to stay current as conventions evolve; every reference file goes stale; every handoff format is a contract two agents must update together. I’ve spent more time renaming fields to keep them consistent than writing the originals — and that’s after the agent-creator did most of the typing.
The shape underneath
Around the fourth or fifth cycle, the agents start producing definitions you accept with minor edits, and your role shifts from author to editor. From there the marginal cost of a new agent is small enough that you add one whenever you notice a gap — which is how you end up with 37 skills without ever deciding to.
The seed is reusable, too. The agent-creator that built the research agent also built the SDLC reviewers and the blog management agents, and every new domain — D&D campaign tooling, Home Assistant health checks, Todoist dispatch — bootstraps against the same seed and accumulated findings.
The “Agentic OS” framing inflates this into something it isn’t. A real OS manages hardware, process isolation, and privilege escalation. What’s actually here is context management, file-based state, and skill routing — useful, but not deserving of the metaphor. The branding sells courses; the pattern underneath doesn’t need it.
That pattern is the same one in the SDLC pipeline and the research workflow: a focused entry point, specialist agents with narrow scope, structured handoffs, and a deterministic skeleton with focused LLM judgment in the middle. The bootstrap loop builds that skeleton. You write the seed by hand because there’s no other way to start — and everything after, the system writes for itself while you read every line.