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

code

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:

markdown

## 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

markdown

**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

markdown

**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:

markdown

**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:

markdown

**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

code

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