Field notes: building with specialized agents
What actually works when you decompose a build across a team of AI agents — parallel research, bounded implementation, and adversarial review — and what still has to be yours.
A note on process rather than product. The way I build has shifted from writing most of the code to specifying and verifying it, with a team of specialized agents doing the middle. It's not magic and it's easy to do badly, so here's what has actually held up.
Decompose by role, then by boundary
The useful decomposition is by role — research, plan, design, implement, review, red-team — and then, within implementation, by file boundary. Agents that touch disjoint parts of the codebase can run in parallel without stepping on each other. Agents that share files will quietly corrupt each other's work. Most of the skill is in carving the problem so the boundaries don't collide.
What works
- Parallel research fan-out. Several agents chasing different questions at once, each returning a synthesis rather than raw results, is genuinely faster than doing it serially.
- Bounded implementation with a tight spec. A precise spec — exact files, exact interfaces, the constraints that matter — is the difference between usable output and a rewrite.
- Adversarial review by a different agent. The reviewer should not be the author. A fresh agent told to attack the work finds what the author rationalized away.
What doesn't
Vague specs, shared files, and trusting output you haven't run. The failure mode is always the same: something that looks plausible and is subtly wrong. You catch it by verifying — running the tests, opening the page, reading the diff — not by admiring the prose. The taste, the architecture, and the final judgment stay with you. Agents are leverage on execution, not a substitute for knowing what good looks like.
The bottleneck moves. It used to be typing. Now it's how clearly you can state what you want and how rigorously you check what you got. Both of those are worth getting good at.