subagent-driven-development · Subagent-Driven Development
Subagent-driven execution of implementation plans: each task gets a fresh implementer subagent (implement/test/commit/self-review), followed by a task reviewer subagent (spec compliance + code quality). Findings enter fix rounds (max 5); after all tasks, a whole-branch final review runs, then finishing-a-development-branch closes it out.
Core principles: fresh subagents prevent context pollution, each task gets independent review, execution never pauses mid-plan to ask "should I continue?" Conflicts are ruled on by the spec, logged as ledger Rulings, and execution continues. Only four stops: irreversible/destructive ops, security-sensitive actions, out-of-worktree side effects, or a hopelessly broken plan.
Example invocation: "Execute this implementation plan subagent-driven."
Full brief
Positioning
subagent-driven-development is an execution engine for implementation plans: for plans with mostly independent tasks. Tightly coupled tasks or inline choice → executing-plans; no plan → brainstorm first.
Core capabilities
- Fresh subagents: one brand-new subagent per task, never inheriting session context — only the precisely constructed task context; the main session keeps coordination.
- Per-task review: implementer subagent (implement/test/commit/self-review) → task reviewer (spec compliance + code quality); conflicts with plan text are ruled per plan and logged as Rulings.
- Fix-round mechanics: findings enter fix rounds (rounds ≤3 resume the implementer; ≥4 bring a fresh, more capable implementer), max 5 rounds; breaker trips → adjudicate each open finding.
- Continuous execution: never pauses between tasks to ask "should I continue?" Rulings don't stall.
- Whole-branch final review: after all tasks, final code review, one fix dispatch, scoped re-review, residual adjudication, then delete the plan workspace.
- Closeout: ends with finishing-a-development-branch for the integration decision.
- Four stops: irreversible/destructive ops, security-sensitive actions, out-of-worktree side effects (merge/push to shared branch/publish), hopelessly broken plan.
Workflow
- Setup (worktree, ledger check, read plan, pre-flight review)
- Per task: dispatch implementer → implement/test/commit/self-review → dispatch reviewer → fix rounds (max 5)
- Log completion to ledger, move to the next task
- All done: whole-branch final review → one fix round → adjudicate residuals
- Delete plan workspace → finishing-a-development-branch closeout
Inputs & outputs
| Input | Notes |
|---|---|
| Implementation plan | Required — mostly independent tasks (writing-plans output) |
| Execution method | User chose subagent-driven (or recommended then chosen) |
Output: all plan tasks executed, reviews passed, branch integration decided.
Boundaries with adjacent skills
| Skill | Lane |
|---|---|
| subagent-driven-development (this) | Fresh subagents per task + per-task review |
| executing-plans | Inline execution in one context (cheaper, review only at end) |
| writing-plans | Writing implementation plans |
| finishing-a-development-branch | Post-execution branch integration decision |
Fit
- Implementation plans with mostly independent tasks
- Independent review per task for quality
- Willing to pay one fresh context per task for quality
Before you start
- Have an implementation plan (writing-plans output).
- Tasks mostly independent; execution method confirmed as subagent-driven.
subagent-driven-development is part of the Aiglade Skill library. Invoke it from the Aiglade chat box in plain language.