/subagent-driven-development

name: subagent-driven-development
description: >
  Executes plans using parallel subagents with per-task implementation
  and staged review gates. Invoke for parallel plan execution in the
  current session. Routed by writing-plans handoff or using-superpowers
  for large plans with independent tasks.

Subagent-Driven Development

Execute a plan with fresh subagents per task and strict review gates.

Required Start

Announce: `I'm using subagent-driven-development to execute this plan.`

Core Flow

digraph sdd_process {
    rankdir=TB;

    subgraph cluster_per_task {
        label="Per Task (or batch)";
        "Dispatch implementer subagent" [shape=box];
        "Implementer asks questions?" [shape=diamond];
        "Answer questions, provide context" [shape=box];
        "Implementer implements, tests, self-reviews" [shape=box];
        "Dispatch ONE task reviewer\n(spec verdict + quality verdict)" [shape=box];
        "Resolve any 'cannot verify from diff' items yourself" [shape=box];
        "Both verdicts pass?" [shape=diamond];
        "Fix round R of 5" [shape=box];
        "R = 5?" [shape=diamond];
        "Adjudicate open findings, record each decision" [shape=box];
        "Mark task complete" [shape=box];
    }

    "Read plan + spec + Global Constraints, create tracking" [shape=box];
    "Pre-flight interface scan" [shape=box];
    "Group into waves; batch same-shape tasks" [shape=box];
    "More tasks?" [shape=diamond];
    "Final whole-branch review" [shape=box];
    "Invoke finishing-a-development-branch" [shape=doublecircle];

    "Read plan + spec + Global Constraints, create tracking" -> "Pre-flight interface scan";
    "Pre-flight interface scan" -> "Group into waves; batch same-shape tasks";
    "Group into waves; batch same-shape tasks" -> "Dispatch implementer subagent";
    "Dispatch implementer subagent" -> "Implementer asks questions?";
    "Implementer asks questions?" -> "Answer questions, provide context" [label="yes"];
    "Answer questions, provide context" -> "Dispatch implementer subagent";
    "Implementer asks questions?" -> "Implementer implements, tests, self-reviews" [label="no"];
    "Implementer implements, tests, self-reviews" -> "Dispatch ONE task reviewer\n(spec verdict + quality verdict)";
    "Dispatch ONE task reviewer\n(spec verdict + quality verdict)" -> "Resolve any 'cannot verify from diff' items yourself";
    "Resolve any 'cannot verify from diff' items yourself" -> "Both verdicts pass?";
    "Both verdicts pass?" -> "Mark task complete" [label="yes"];
    "Both verdicts pass?" -> "Fix round R of 5" [label="no"];
    "Fix round R of 5" -> "R = 5?";
    "R = 5?" -> "Dispatch ONE task reviewer\n(spec verdict + quality verdict)" [label="no - re-review"];
    "R = 5?" -> "Adjudicate open findings, record each decision" [label="yes - breaker trips"];
    "Adjudicate open findings, record each decision" -> "Mark task complete";
    "Mark task complete" -> "More tasks?";
    "More tasks?" -> "Dispatch implementer subagent" [label="yes"];
    "More tasks?" -> "Final whole-branch review" [label="no"];
    "Final whole-branch review" -> "Invoke finishing-a-development-branch";
}

1. Read the plan once and extract all tasks. Note its **Global Constraints** block and its **Spec:** pointer — if the plan names a spec, read that too. The spec is the authority the plan argues from, so conflicts inside the plan resolve against it. A plan with no reachable spec is workable, but any judgment call you make without one is provisional — say so when you report. 2. Create task tracking for all tasks. 3. **Pre-flight interface scan.** Before dispatching Task 1, check the plan's Interfaces blocks against each other: for every task whose `Consumes` list names something, confirm an earlier task's `Produces` list defines it with the same name and shape. Mismatches found here cost one edit to the plan; the same mismatch found mid-run costs a failed task, a fix round, and a re-review. Raise everything you find in one pass rather than stumbling into it task by task. A plan whose tasks share no interfaces needs no scan — say so and move on. 4. Group tasks into waves, and batch same-shape tasks (see *Batching Same-Shape Tasks* below). 5. For each task or batch:

• Run `bash scripts/task-brief PLAN_FILE N` and dispatch the implementer with the **brief path** it prints — not the pasted task text (see *Handing Work Over as Files*).
• Resolve implementer questions before coding.
• Require implementer verification evidence.
• Run `bash scripts/review-package PLAN_FILE BASE HEAD`, then dispatch **one** task review with the package path — both a spec verdict and a quality verdict (see *Task Review* below).
• Resolve any "cannot verify from diff" items yourself before marking complete.
• If either verdict fails, run a fix round and re-review. Five rounds maximum.
• Mark task complete: update the task's checkbox in plan.md from `- [ ]` to `- [x]`. If `state.md` exists with a plan status section, update it to reflect the completed task.
• For complex or high-risk tasks, validate the approach against requirements and consider simpler alternatives before or after the implementer's work.
• For tasks centered on frontend/UI, apply `frontend-design` standards to guide structure, styling, and accessibility.

6. Run final whole-branch review on the most capable model available: `bash scripts/review-package PLAN_FILE $(git merge-base origin/main HEAD) HEAD`, then dispatch `requesting-code-review` with that package path and the plan's **Review Focus** section verbatim. Name the model explicitly — an omitted model silently inherits the session's. 7. Invoke `finishing-a-development-branch`.

Parallel Waves (default for independent tasks)

When tasks are independent and touch disjoint files, dispatch them as a wave — this is the preferred mode, not a special case. Sequential execution is the fallback for dependent tasks, not the default.

**Decision rule:**