Subagent Driven Development

{
  "sections": {
    "Example Workflow": "```\r\nYou: I'm using Subagent-Driven Development to execute this plan.\r\n\r\n[Load plan, create TodoWrite]\r\n\r\nTask 1: Hook installation script\r\n\r\n[Dispatch implementation subagent]\r\nSubagent: Implemented install-hook with tests, 5/5 passing\r\n\r\n[Get git SHAs, dispatch code-reviewer]\r\nReviewer: Strengths: Good test coverage. Issues: None. Ready.\r\n\r\n[Mark Task 1 complete]\r\n\r\nTask 2: Recovery modes\r\n\r\n[Dispatch implementation subagent]\r\nSubagent: Added verify/repair, 8/8 tests passing\r\n\r\n[Dispatch code-reviewer]\r\nReviewer: Strengths: Solid. Issues (Important): Missing progress reporting\r\n\r\n[Dispatch fix subagent]\r\nFix subagent: Added progress every 100 conversations\r\n\r\n[Verify fix, mark Task 2 complete]\r\n\r\n...\r\n\r\n[After all tasks]\r\n[Dispatch final code-reviewer]\r\nFinal reviewer: All requirements met, ready to merge\r\n\r\nDone!\r\n```",
    "Overview": "**vs. Executing Plans (parallel session):**\r\n- Same session (no context switch)\r\n- Fresh subagent per task (no context pollution)\r\n- Code review after each task (catch issues early)\r\n- Faster iteration (no human-in-loop between tasks)\r\n\r\n**When to use:**\r\n- Staying in this session\r\n- Tasks are mostly independent\r\n- Want continuous progress with quality gates\r\n\r\n**When NOT to use:**\r\n- Need to review plan first (use executing-plans)\r\n- Tasks are tightly coupled (manual execution better)\r\n- Plan needs revision (brainstorm first)",
    "The Process": "### 1. Load Plan\r\n\r\nRead plan file, create TodoWrite with all tasks.\r\n\r\n### 2. Execute Task with Subagent\r\n\r\nFor each task:\r\n\r\n**Dispatch fresh subagent:**\r\n```\r\nTask tool (general-purpose):\r\n  description: \"Implement Task N: [task name]\"\r\n  prompt: |\r\n    You are implementing Task N from [plan-file].\r\n\r\n    Read that task carefully. Your job is to:\r\n    1. Implement exactly what the task specifies\r\n    2. Write tests (following TDD if task says to)\r\n    3. Verify implementation works\r\n    4. Commit your work\r\n    5. Report back\r\n\r\n    Work from: [directory]\r\n\r\n    Report: What you implemented, what you tested, test results, files changed, any issues\r\n```\r\n\r\n**Subagent reports back** with summary of work.\r\n\r\n### 3. Review Subagent's Work\r\n\r\n**Dispatch code-reviewer subagent:**\r\n```\r\nTask tool (superpowers:code-reviewer):\r\n  Use template at requesting-code-review/code-reviewer.md\r\n\r\n  WHAT_WAS_IMPLEMENTED: [from subagent's report]\r\n  PLAN_OR_REQUIREMENTS: Task N from [plan-file]\r\n  BASE_SHA: [commit before task]\r\n  HEAD_SHA: [current commit]\r\n  DESCRIPTION: [task summary]\r\n```\r\n\r\n**Code reviewer returns:** Strengths, Issues (Critical/Important/Minor), Assessment\r\n\r\n### 4. Apply Review Feedback\r\n\r\n**If issues found:**\r\n- Fix Critical issues immediately\r\n- Fix Important issues before next task\r\n- Note Minor issues\r\n\r\n**Dispatch follow-up subagent if needed:**\r\n```\r\n\"Fix issues from code review: [list issues]\"\r\n```\r\n\r\n### 5. Mark Complete, Next Task\r\n\r\n- Mark task as completed in TodoWrite\r\n- Move to next task\r\n- Repeat steps 2-5\r\n\r\n### 6. Final Review\r\n\r\nAfter all tasks complete, dispatch final code-reviewer:\r\n- Reviews entire implementation\r\n- Checks all plan requirements met\r\n- Validates overall architecture\r\n\r\n### 7. Complete Development\r\n\r\nAfter final review passes:\r\n- Announce: \"I'm using the finishing-a-development-branch skill to complete this work.\"\r\n- **REQUIRED SUB-SKILL:** Use superpowers:finishing-a-development-branch\r\n- Follow that skill to verify tests, present options, execute choice",
    "Advantages": "**vs. Manual execution:**\r\n- Subagents follow TDD naturally\r\n- Fresh context per task (no confusion)\r\n- Parallel-safe (subagents don't interfere)\r\n\r\n**vs. Executing Plans:**\r\n- Same session (no handoff)\r\n- Continuous progress (no waiting)\r\n- Review checkpoints automatic\r\n\r\n**Cost:**\r\n- More subagent invocations\r\n- But catches issues early (cheaper than debugging later)",
    "Integration": "**Required workflow skills:**\r\n- **writing-plans** - REQUIRED: Creates the plan that this skill executes\r\n- **requesting-code-review** - REQUIRED: Review after each task (see Step 3)\r\n- **finishing-a-development-branch** - REQUIRED: Complete development after all tasks (see Step 7)\r\n\r\n**Subagents must use:**\r\n- **test-driven-development** - Subagents follow TDD for each task\r\n\r\n**Alternative workflow:**\r\n- **executing-plans** - Use for parallel session instead of same-session execution\r\n\r\nSee code-reviewer template: requesting-code-review/code-reviewer.md",
    "Red Flags": "**Never:**\r\n- Skip code review between tasks\r\n- Proceed with unfixed Critical issues\r\n- Dispatch multiple implementation subagents in parallel (conflicts)\r\n- Implement without reading plan task\r\n\r\n**If subagent fails task:**\r\n- Dispatch fix subagent with specific instructions\r\n- Don't try to fix manually (context pollution)"
  },
  "content": "Execute plan by dispatching fresh subagent per task, with code review after each.\r\n\r\n**Core principle:** Fresh subagent per task + review between tasks = high quality, fast iteration",
  "id": "subagent-driven-development_obra",
  "name": "subagent-driven-development",
  "description": "Use when executing implementation plans with independent tasks in the current session - dispatches fresh subagent for each task with code review between tasks, enabling fast iteration with quality gates"
}

---
name: subagent-driven-development
description: Use when executing implementation plans with independent tasks in the current session - dispatches fresh subagent for each task with code review between tasks, enabling fast iteration with quality gates
---

# Subagent-Driven Development

Execute plan by dispatching fresh subagent per task, with code review after each.

**Core principle:** Fresh subagent per task + review between tasks = high quality, fast iteration

## Overview

**vs. Executing Plans (parallel session):**
- Same session (no context switch)
- Fresh subagent per task (no context pollution)
- Code review after each task (catch issues early)
- Faster iteration (no human-in-loop between tasks)

**When to use:**
- Staying in this session
- Tasks are mostly independent
- Want continuous progress with quality gates

**When NOT to use:**
- Need to review plan first (use executing-plans)
- Tasks are tightly coupled (manual execution better)
- Plan needs revision (brainstorm first)

## The Process

### 1. Load Plan

Read plan file, create TodoWrite with all tasks.

### 2. Execute Task with Subagent

For each task:

**Dispatch fresh subagent:**
```
Task tool (general-purpose):
  description: "Implement Task N: [task name]"
  prompt: |
    You are implementing Task N from [plan-file].

    Read that task carefully. Your job is to:
    1. Implement exactly what the task specifies
    2. Write tests (following TDD if task says to)
    3. Verify implementation works
    4. Commit your work
    5. Report back

    Work from: [directory]

    Report: What you implemented, what you tested, test results, files changed, any issues
```

**Subagent reports back** with summary of work.

### 3. Review Subagent's Work

**Dispatch code-reviewer subagent:**
```
Task tool (superpowers:code-reviewer):
  Use template at requesting-code-review/code-reviewer.md

  WHAT_WAS_IMPLEMENTED: [from subagent's report]
  PLAN_OR_REQUIREMENTS: Task N from [plan-file]
  BASE_SHA: [commit before task]
  HEAD_SHA: [current commit]
  DESCRIPTION: [task summary]
```

**Code reviewer returns:** Strengths, Issues (Critical/Important/Minor), Assessment

### 4. Apply Review Feedback

**If issues found:**
- Fix Critical issues immediately
- Fix Important issues before next task
- Note Minor issues

**Dispatch follow-up subagent if needed:**
```
"Fix issues from code review: [list issues]"
```

### 5. Mark Complete, Next Task

- Mark task as completed in TodoWrite
- Move to next task
- Repeat steps 2-5

### 6. Final Review

After all tasks complete, dispatch final code-reviewer:
- Reviews entire implementation
- Checks all plan requirements met
- Validates overall architecture

### 7. Complete Development

After final review passes:
- Announce: "I'm using the finishing-a-development-branch skill to complete this work."
- **REQUIRED SUB-SKILL:** Use superpowers:finishing-a-development-branch
- Follow that skill to verify tests, present options, execute choice

## Example Workflow

```
You: I'm using Subagent-Driven Development to execute this plan.

[Load plan, create TodoWrite]

Task 1: Hook installation script

[Dispatch implementation subagent]
Subagent: Implemented install-hook with tests, 5/5 passing

[Get git SHAs, dispatch code-reviewer]
Reviewer: Strengths: Good test coverage. Issues: None. Ready.

[Mark Task 1 complete]

Task 2: Recovery modes

[Dispatch implementation subagent]
Subagent: Added verify/repair, 8/8 tests passing

[Dispatch code-reviewer]
Reviewer: Strengths: Solid. Issues (Important): Missing progress reporting

[Dispatch fix subagent]
Fix subagent: Added progress every 100 conversations

[Verify fix, mark Task 2 complete]

...

[After all tasks]
[Dispatch final code-reviewer]
Final reviewer: All requirements met, ready to merge

Done!
```

## Advantages

**vs. Manual execution:**
- Subagents follow TDD naturally
- Fresh context per task (no confusion)
- Parallel-safe (subagents don't interfere)

**vs. Executing Plans:**
- Same session (no handoff)
- Continuous progress (no waiting)
- Review checkpoints automatic

**Cost:**
- More subagent invocations
- But catches issues early (cheaper than debugging later)

## Red Flags

**Never:**
- Skip code review between tasks
- Proceed with unfixed Critical issues
- Dispatch multiple implementation subagents in parallel (conflicts)
- Implement without reading plan task

**If subagent fails task:**
- Dispatch fix subagent with specific instructions
- Don't try to fix manually (context pollution)

## Integration

**Required workflow skills:**
- **writing-plans** - REQUIRED: Creates the plan that this skill executes
- **requesting-code-review** - REQUIRED: Review after each task (see Step 3)
- **finishing-a-development-branch** - REQUIRED: Complete development after all tasks (see Step 7)

**Subagents must use:**
- **test-driven-development** - Subagents follow TDD for each task

**Alternative workflow:**
- **executing-plans** - Use for parallel session instead of same-session execution

See code-reviewer template: requesting-code-review/code-reviewer.md