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