Subagent-Driven Development Skill

Overview

This skill implements structured plan execution by dispatching independent subagents for each task, followed by mandatory two-stage reviews: specification compliance first, then code quality. Ensures systematic progress with quality gates.

Quick Start

Prepare plan - Extract tasks to TodoWrite tracker
For each task:
- Dispatch implementer subagent
- Answer clarification questions
- Run spec compliance review
- Run code quality review
Final review - Comprehensive code review
Complete - Use finishing-a-development-branch

When to Use

Executing implementation plans with mostly independent tasks
Need to remain in current session
Quality gates required between tasks
Context preservation across multiple steps

Don't use when:

Tasks are tightly coupled
Parallel execution preferred
Simple, single-file changes

Process Flow

Plan → [Task 1] → Implement → Spec Review → Quality Review → ✓
                                  ↓              ↓
                               Fix & Re-review if needed
       [Task 2] → Implement → Spec Review → Quality Review → ✓
       ...
       Final Review → Complete

Detailed Process

Step 1: Plan Preparation

Extract all tasks with full context:

## Task Extraction

From plan, create TodoWrite entries:
- [ ] Task 1: [Description with full context]
- [ ] Task 2: [Description with full context]
- [ ] Task 3: [Description with full context]

Important: Provide extracted text to subagents, don't make them read plan files.

Step 2: Per-Task Execution

For each task:

2a. Dispatch Implementer

**Implementer Subagent Prompt:**

Implement the following task:

[Complete task text from plan]

Requirements:
- Follow TDD: write test first, verify failure, implement, verify pass
- Make atomic commits
- Self-review before signaling completion
- Ask clarifying questions if needed

Signal completion with summary of:
- Files changed
- Tests added/modified
- Any deviations from plan

2b. Handle Clarifications

If implementer asks questions:

Answer before implementation begins
Don't let implementer proceed with assumptions
Document answers for future reference

2c. Spec Compliance Review

**Spec Reviewer Subagent Prompt:**

Review the implementation for specification compliance:

**Original task spec:**
[Task text from plan]

**Changes made:**
[Summary from implementer]

Verify:
- [ ] All requirements from spec implemented
- [ ] No requirements missed
- [ ] No extra features added (YAGNI)
- [ ] Implementation matches described approach

Report: PASS or FAIL with specific issues

If FAIL: Fix issues, re-run spec review.

2d. Code Quality Review

Only after spec review passes:

**Quality Reviewer Subagent Prompt:**

Review the implementation for code quality:

**Files changed:**
[List of files]

Review for:
- [ ] Code clarity and readability
- [ ] Error handling
- [ ] Test coverage and quality
- [ ] Performance considerations
- [ ] Security implications
- [ ] Adherence to project conventions

Report: PASS or FAIL with specific issues

If FAIL: Fix issues, re-run quality review.

2e. Mark Complete

After both reviews pass:

Mark task as complete in TodoWrite
Move to next task

Step 3: Final Review

After all tasks complete:

**Final Reviewer Subagent Prompt:**

Conduct comprehensive code review of all changes:

**Tasks completed:**
[List of all tasks]

**Files modified:**
[Complete file list]

Review for:
- [ ] Overall architectural coherence
- [ ] Cross-task consistency
- [ ] Integration correctness
- [ ] Complete test coverage
- [ ] Documentation completeness

Report: PASS or specific issues to address

Step 4: Completion

Use finishing-a-development-branch skill:

Decide: merge to main or create PR
Handle cleanup
Update tracking

Critical Rules

Never

Skip reviews (spec compliance OR code quality)
Start code quality review before spec compliance passes
Dispatch multiple implementation subagents in parallel
Make subagents read plan files directly
Accept reviews with unresolved issues
Continue to next task before current passes both reviews

Always

Provide extracted text to subagents
Answer clarifications before implementation
Fix issues before re-review
Document deviations from plan
Run both review stages in order

Review Order Rationale

1. Spec Compliance (Does it do the right thing?)
   ↓
2. Code Quality (Does it do it well?)

Spec first because:

No point polishing wrong code
Requirements drive design decisions
Quality review assumes correct functionality

Best Practices

Do

Extract complete task context
Include expected outcomes in implementer prompt
Be specific in review criteria
Fix issues immediately when found
Keep TodoWrite updated
Document any plan deviations

Don't

Rush through reviews
Batch multiple tasks before review
Skip re-review after fixes
Let implementer guess at requirements
Accept "mostly passing" reviews
Proceed with unresolved questions

Error Handling

Situation	Action
Implementer asks question	Answer fully, then proceed
Spec review fails	Fix specific issues, re-review
Quality review fails	Fix specific issues, re-review
Task blocked by dependency	Complete dependency first
Plan needs revision	Update plan, re-extract tasks

Metrics

Metric	Target	Description
First-pass spec compliance	>80%	Tasks passing spec review first time
First-pass quality	>70%	Tasks passing quality review first time
Re-review cycles	<2	Average re-reviews per task
Task completion rate	100%	Tasks completed as planned

Related Skills

writing-plans - Create implementation plans
tdd-obra - Test-first development
code-reviewer - Code quality review
parallel-dispatch - Parallel execution

Version History

1.0.0 (2026-01-19): Initial release adapted from obra/superpowers

subagent-driven