subagent-driven-development

Executes implementation plans by dispatching fresh subagents per task with staged code reviews.

Updated Aug 14, 2026
One-click install
npx skills add https://github.com/bill80362/laravel-thread-admin --skill subagent-driven-development-bill80362
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: subagent-driven-development
Source: https://github.com/bill80362/laravel-thread-admin/tree/main/.github/superpowers/subagent-driven-development
Command: npx skills add https://github.com/bill80362/laravel-thread-admin --skill subagent-driven-development-bill80362

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve? Executing a multi-task implementation plan in a single AI session leads to context pollution, lost progress after context compaction, and unreviewed code. This Skill orchestrates plan execution by delegating each task to an isolated subagent with its own context, enforcing per-task spec and quality reviews, and tracking progress in a ledger file that survives compaction. ## Core Features & Use Cases - Isolated Task Execution: Dispatches a fresh implementer subagent per task using extracted task briefs, so no subagent inherits session history or unrelated context. - Two-Stage Review Gates: Runs a task-level review (spec compliance plus code quality) after every task and a final whole-branch review with the strongest available model before finishing. - Bounded Fix Loop with Circuit Breaker: Cycles up to five fix rounds per task—re-summoning the original implementer for rounds 1-3, escalating to a stronger model for rounds 4-5—then adjudicates or escalates unresolved findings instead of looping forever. - Compaction-Safe Progress Ledger: Records task completion, fix rounds, and parked findings in a per-plan workspace under .superpowers/sdd/, enabling reliable resume after context loss. - Use Case: You have a written implementation plan with eight mostly independent tasks. Invoke this Skill to execute all tasks end-to-end: each is implemented, tested, reviewed, and committed by dedicated subagents while you retain a clean coordination context. ## Quick Start Execute the implementation plan at docs/plans/feature-plan.md using subagent-driven development, dispatching a fresh implementer subagent for each task and reviewing each one before moving on.

Frequently Asked Questions about subagent-driven-development

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I execute an implementation plan with AI subagents?

Dispatch one fresh implementer subagent per task with an extracted task brief file, then run a task review on the resulting diff before marking the task complete. Track progress in a ledger file so completed tasks are never re-dispatched after context compaction.

What is the difference between subagent-driven development and executing plans in parallel sessions?

Subagent-driven development stays in one session and gives each task a fresh isolated subagent context, avoiding both context pollution and session switching. Parallel-session plan execution suits tightly coupled tasks but requires manual coordination across sessions.

How many fix rounds should a code review loop allow?

This workflow caps the fix loop at five rounds per task: rounds 1-3 re-summon the original implementer, rounds 4-5 dispatch a fresh implementer with a stronger model. If findings remain after round five, the controller adjudicates each one or reports the task as blocked.

Why should code review diffs be passed as files instead of pasted?

Passing diffs as generated review-package files keeps large diffs out of the controller's context, which must stay clean for coordination. The reviewer reads the commit list, stat summary, and full diff in a single file read.

When should I not use subagent-driven development?

Avoid it when tasks are tightly coupled and cannot be specified independently, or when no written implementation plan exists yet. In those cases, brainstorm or write the plan first, or execute manually in a single continuous context.