subagent-driven-development
Use when executing implementation plans. Dispatches independent subagents for individual tasks with code review checkpoints between iterations for rapid, controlled development.
When & Why to Use This Skill
Subagent-Driven Development (SDD) is an advanced orchestration framework for Claude designed to execute complex software implementation plans with high precision. By dispatching independent subagents for isolated tasks, it ensures a clean context for every code change, preventing the 'context drift' common in long development sessions. This skill prioritizes controlled progress through mandatory review checkpoints, allowing developers to maintain rigorous code quality while benefiting from the speed of autonomous agentic workflows.
Use Cases
- Complex Feature Implementation: Executing multi-step technical roadmaps by breaking them into discrete, manageable tasks handled by fresh subagents.
- Large-scale Refactoring: Safely updating legacy codebases by isolating refactoring steps into independent units with individual test-driven validation.
- Quality-Controlled AI Coding: Implementing a 'Human-in-the-Loop' workflow where every AI-generated change is reviewed and approved before the next task begins.
- Context Optimization: Preventing AI performance degradation in large projects by resetting the subagent's environment for every specific sub-task, ensuring maximum focus and accuracy.
| name | subagent-driven-development |
|---|---|
| description | Use when executing implementation plans. Dispatches independent subagents for individual tasks with code review checkpoints between iterations for rapid, controlled development. |
Subagent-Driven Development
Core Principle
Fresh context per task. Review between tasks.
Each task gets a clean subagent with no accumulated confusion. You review between tasks.
How It Works
- Load the implementation plan
- For each task:
- Dispatch fresh subagent
- Subagent implements ONLY that task
- Review the changes
- Approve or request fixes
- Move to next task
Benefits
- Clean Context: Each subagent starts fresh
- Focused Work: One task at a time
- Review Points: Catch issues early
- Controlled Progress: You stay in charge
Execution Flow
Step 1: Load the Plan
Loading plan from: docs/plans/YYYY-MM-DD-feature-name.md
Tasks identified:
1. [ ] Task 1: Description
2. [ ] Task 2: Description
3. [ ] Task 3: Description
Starting with Task 1...
Step 2: Dispatch Subagent
For each task, create a focused prompt:
## Task: [Task Name]
### Context
- Project: [brief description]
- Current branch: [branch name]
- Dependencies: [relevant info]
### Instructions
[Exact instructions from plan]
### Files to Modify
- `path/to/file.ts`
### Test to Write First
[Test code from plan]
### Implementation
[Implementation code from plan]
### Success Criteria
- [ ] Test passes
- [ ] No other tests broken
- [ ] Code follows project style
Step 3: Review Changes
After subagent completes:
## Task 1 Complete
### Changes Made:
- Modified: `path/to/file.ts` (+25/-3)
- Added: `path/to/file.test.ts` (+40)
### Test Results:
✅ All tests passing (47 total)
### Review Checklist:
- [ ] Test covers the requirement
- [ ] Implementation is correct
- [ ] No unnecessary changes
- [ ] Code style matches project
**Approve and continue to Task 2?**
Step 4: Handle Issues
If review finds problems:
## Issues Found in Task 1
1. Test doesn't cover edge case X
2. Missing error handling for Y
**Options:**
A) Request fixes from subagent
B) Fix manually
C) Skip and note for later
Which approach?
Subagent Guidelines
What Subagents Should Do
- Follow the plan exactly
- Write tests first
- Make minimal changes
- Report what was done
What Subagents Should NOT Do
- Make "improvements" outside scope
- Skip tests
- Refactor unrelated code
- Change the plan
Progress Tracking
Maintain task status:
## Progress: Feature Name
- [x] Task 1: Setup database schema ✅
- [x] Task 2: Create API endpoint ✅
- [ ] Task 3: Add validation (IN PROGRESS)
- [ ] Task 4: Write integration tests
- [ ] Task 5: Update documentation
Current: Task 3 of 5
Checkpoints
After Each Task
- Run all tests
- Review diff
- Commit if approved
After All Tasks
- Run integration tests
- Manual verification
- Final review
Rollback
If things go wrong:
# Revert last task
git revert HEAD
# Or reset to checkpoint
git reset --hard <commit-before-task>
Communication Pattern
Starting
"I'm using subagent-driven-development to implement [feature]. I'll dispatch a fresh subagent for each task and review between them."
Between Tasks
"Task [N] complete. Changes: [summary]. Ready to review before Task [N+1]?"
Completing
"All [N] tasks complete. Running final verification..."