recursive-development

Recursive Development

Decompose work into waves of parallel nested subagents. Works for greenfield and existing codebases. Each wave completes before the next starts. Within a wave, independent modules run in parallel. No depth limit on nesting.

For existing projects, Wave 0 extends established patterns rather than creating from scratch.

Nesting

Default to nesting. Each nested agent has smaller context -- faster and cheaper per-agent. A flat agent juggling 7 files costs more than 3 focused agents each handling 2-3 files.

Nest when a module contains distinct algorithms or domains. Stop when atomic (single concern, single file). Split by algorithm or domain, not by testability alone.

When to split -- examples

The same principle applies at every level of recursion:

Split (distinct algorithms or domains):

• Parsers + filters + aggregation + formatters -- different domains
• Cycle detection + topological sort -- different graph algorithms
• JSONL parser + CLF parser + CSV parser -- different parsing algorithms
• Expression parser + predicate evaluator -- syntax parsing vs logic evaluation

Don't split (steps in one operation, or trivial wrappers):

• File discovery + file reading + format detection -- one operation ("load config")
• A parser that just delegates to a validator -- no distinct logic
• Output capture separate from execution -- capturing is part of executing

Role	Scope	Spawns when...
Orchestrator	Shared files + wave sequencing	Always
Module agent	Directory scope	2+ testable concerns
Component agent	File set scope	Separable sub-concerns
Leaf agent	Single file pair	Never -- implements directly

Model selection

Level	Recommended model
Orchestrator	opus -- decomposition, contract design
Module/component	sonnet -- focused, contract-constrained

Scope-Based Ownership

No two parallel subagents may touch the same file.