What does this skill do, and when should you use it?
Subagent-Driven Development is one skill in the Superpowers collection, designed to execute implementation plans with mostly independent tasks in the current session. It dispatches a fresh implementer subagent for each task, followed by reviews for specification compliance and code quality. After all tasks are complete, it runs a broad whole-branch code review. It fits coding-agent workflows that need continuous execution with explicit quality checkpoints.
Reads an implementation plan and creates todos; prepares a task brief for each independent task; dispatches a fresh implementer subagent; has the implementer implement, test, commit, and self-review; creates a diff review package and dispatches a task reviewer for specification compliance and code quality; dispatches fix work for Critical or Important findings and repeats review; records completed tasks in a progress ledger; and dispatches a final whole-branch code reviewer after all tasks are finished. The workflow reads and writes local files and uses Git for commits and diffs.
- An engineer with a multi-task implementation plan who wants a coding agent to work through the tasks continuously.
- A developer who wants each engineering task handled in isolated subagent context.
- A team that needs specification and code-quality checks after every task, not only at the end.
- A coding-agent user who wants to execute several independent tasks without human check-ins between them.
How do you install this skill?
- The workflow drives subagents to implement, test, commit, and write progress/review artifacts; users should establish explicit confirmation, permission, sensitive-data, and rollback controls before use.
- Key scripts, templates, and companion skills are not fully included in the selected evidence; installation or version mismatches may interrupt the workflow and require environment-specific validation.
- Chinese interaction and mainland-China compatibility are not declared. The local core process is not shown to depend entirely on overseas services, but cross-harness integrations may be environment-constrained.
- Shell / CLI
- Local filesystem
Git
The source does not document standalone installation for this skill; it is bundled with the 14-skill obra/superpowers repository. Install the Superpowers collection through your coding-agent harness. For Claude Code, run /plugin install superpowers@claude-plugins-official. For Codex CLI, open /plugins, search for superpowers, and select Install Plugin.
tmp="$(mktemp -d)"
git clone --depth 1 https://github.com/obra/superpowers.git "$tmp"
mkdir -p ~/.claude/skills
cp -R "$tmp/skills/subagent-driven-development" ~/.claude/skills/
rm -rf "$tmp"Generated from the source repository and skill path; it copies only this skill's folder. If the author's install steps above differ, follow those first. To scope it to one project, replace ~/.claude/skills with that project's .claude/skills.
How do you use this skill?
Prepare an implementation plan containing mostly independent tasks, then ask the coding agent in the current session to execute that plan. The workflow dispatches a fresh implementer and task reviewer for each task, resolves important findings through fixes and re-review, and performs a broad branch review after the final task.
What are this skill's strengths and limitations?
- Fresh context is used for each task, reducing context pollution.
- Each task has separate specification-compliance and code-quality review gates.
- Important findings are sent through a fix-and-re-review loop.
- Git commits and a progress ledger provide durable execution records.
- It requires an implementation plan; it is not the planning step itself.
- It assumes a coding-agent environment that can dispatch subagents, run shell commands, and access the filesystem.
- The implementer-reviewer loop increases subagent invocations and controller preparation work.
- The source does not provide standalone installation instructions or a standalone test suite for this skill.
How does this skill compare with similar options?
Side by side with related skills; every score comes from the same FSRS standard.
| Skill | FS score | Stars | Last updated | License |
|---|---|---|---|---|
| Subagent-Driven Development this page | 50 · Use with care | ★ 299k | 15d ago | MIT |
| Writing Implementation Plans | 42 · Not recommended | ★ 2.9k | 11d ago | Apache-2.0 |
| cmux Review — Pre-merge Agent Code Review | 55 · Use with care | ★ 28k | 11d ago | NOASSERTION |
| Handoff Plan | 47 · Use with care | ★ 64 | 8d ago | MIT |
| PR Babysitter: Watch Pull Requests Until Merge | 47 · Use with care | ★ 101k | 12d ago | Apache-2.0 |
The source explicitly contrasts this skill with executing-plans: this skill stays in the same session and uses a fresh subagent plus review after each task, while executing-plans is intended for a parallel session with human checkpoints.
How did FollowSkills review this skill?
The skill requires isolated context, per-task review, avoidance of direct implementation on the main branch, and explicit handling of blocked work. However, it does not define least privilege, sensitive-data flows, confirmation for commits or other external effects, rollback procedures, or user approval gates, so points are deducted. No malware, credential theft, covert exfiltration, or destructive-default red line is evident. Publisher identity is unknown by rule and is not separately penalized.
The process, status taxonomy, review loops, and failure feedback are detailed and make the happy path plausible. However, it depends on unprovided scripts, prompt templates, and companion skills; this review is static and contains no executable evidence covering key paths, so reproducibility and abnormal-environment confidence are limited.
Trigger conditions, intended scenarios, and the boundary with executing-plans are reasonably clear, including the requirement for mostly independent tasks in the same session. It does not specify broader non-fit ranges, input/output contracts, Chinese-language support, or mainland-China environment compatibility, and semantic invocation still depends on correctly recognizing an implementation plan.
The skill has layered documentation, diagrams, templates, examples, red flags, and integration guidance. Repository context supplies MIT licensing, a version, and maintenance/update signals. The skill itself lacks versioning, changelog, explicit maintenance ownership, and a complete standalone installation/dependency section; several assumptions are distributed across shared repository context, so points are deducted.
The documented workflow directly targets implementation, testing, self-review, task review, fixes, and final review, plausibly reducing context pollution and omissions. Static source provides no representative executed outputs or independent validation, and the benefit over manual execution is mainly asserted, so the score remains below the static ceiling.
The selected skill and its templates are auditable primary material, with traceable process requirements. There is no skill-specific committed test suite, CI coverage, or third-party reproduction evidence, and nothing was executed in this review, so only limited static verifiability is awarded.
Open a dimension to read why it scored that way
Evidence confidence：Low — Mostly static review, author material or a limited demo; useful for discovery, not high-risk decisions.
See the full review method →