Coordinates multiple AI subagents on slices of a larger plan where each subagent handles a defined scope while a single parent agent retains accountability for integration, quality, and final delivery. This approach is valuable when a single agent working sequentially would be too slow, but you still need coherent end-to-end quality rather than fragmented outputs.
Use cases
- Building a multi-section application where each section (auth, API, frontend) can be developed independently
- Generating a long-form content piece with distinct sections that each require different expertise
- Running a parallel implementation of a feature with two approaches to compare before selecting one
- Breaking up a codebase refactor where different modules have different risk profiles and need different review intensity
- Scaling a code review across a large PR where sections require different domain expertise
Key features
- Define the spine task: the overall goal, the shared interfaces between slices, and the criteria for a successful integration
- Delegate isolated subtasks to subagents with explicit contracts—each subagent should know what its inputs are, what its outputs should be, and what it should not touch
- Collect outputs from subagents and verify they meet the interface contracts before combining them
- Review the integrated whole for cross-cutting concerns (error handling consistency, logging conventions, shared types) that individual subagents may have handled differently
- Run end-to-end verification against the original brief to confirm the combined output meets the overall goal
When to Use This Skill
- When a project can be cleanly decomposed into independent slices with well-defined interfaces
- When a single agent would exceed its context window or token budget on a large task
- When different slices require different expertise or tools that are better dispatched to specialized subagents
Expected Output
An integrated deliverable that combines subagent outputs, with a verification report confirming the full brief is met and cross-cutting concerns are resolved.
Frequently Asked Questions
- How do I prevent subagents from diverging on shared types or interfaces?
- Define the interface contracts explicitly before dispatching and provide shared type definitions as part of the subagent brief. Treat interface violations as must-fix items before integration proceeds.
- What if a subagent produces an output that does not integrate cleanly with the others?
- Build a reconciliation step into the workflow where the parent agent reviews integration friction and either re-dispatches the conflicting subagent with corrected constraints or manually bridges the gap.
- How does this differ from dispatching parallel agents?
- Parallel agents are independent workers with no shared accountability. Subagent-driven development has a parent agent that retains responsibility for quality and integration. Use parallel dispatch when the aggregator is a simple merge; use subagent coordination when integration requires judgment.
Related
Related
3 Indexed items
Test-driven development
Drives development through red-green-refactor cycles where you write a failing test that names the desired behavior before writing any implementation code. TDD produces tests that document intent, catches regressions immediately, and forces small, verifiable increments—making it especially valuable for complex features, bug fixes with known failure cases, and any code that needs a long-term safety net.
Dispatching parallel agents
Distributes embarrassingly parallel work across multiple AI agents with clear briefs and crisp handoff protocols, then aggregates their results through a single integrator. This technique maximizes throughput when tasks are independent and the coordination overhead is low, making it ideal for research chunks, file batches, or parallel data processing.
Multi-agent orchestration
Coordinates multiple AI agents on shared tasks with explicit handoff protocols, shared state management, and conflict resolution so parallel work stays coherent. Multi-agent orchestration is more structured than simple parallel dispatch because agents take on distinct roles with explicit dependencies rather than running identical briefs on independent data.