Source: obra/superpowers · Maintainer: community: Jesse Vincent (Prime Radiant) · License: MIT · Checked: 24 October 2026
What is the subagent driven development skill?
Subagent driven development is a way to execute a written plan in which the main agent never writes the code itself: it sends each task to a fresh implementer subagent, has a fresh reviewer check that task, and only then moves to the next. At the end, one more reviewer checks the whole branch.
It is one of two execution skills in Superpowers, the open source library by Jesse Vincent and Prime Radiant, and the one that plans from the writing plans skill recommend. The skill's description reads: "Use when executing implementation plans with independent tasks in the current session".
The README calls it the most thorough of the two execution options. Its skills.sh page listed about 237,500 installs (snapshot, 24 October 2026), and all three security audits shown there (Gen Agent Trust Hub, Socket and Snyk) were Pass.
What does it do?
The SKILL.md sums it up as: "Fresh subagent per task + task review (spec + quality) + broad final review = high quality, fast iteration". Subagents get exactly the context they need and never inherit the session's history, which also keeps the controller's own context free for coordination.
Setup. The controller works in an isolated worktree and never starts on main or master without your consent. scripts/sdd-workspace creates a git-ignored folder for the plan under .superpowers/sdd/ with a ledger, progress.md, that survives context compaction. It reads the plan and its spec, then runs a pre-flight scan for conflicting tasks.
Per task:
- Brief.
scripts/task-briefcopies the task's full text to a file. The implementer reads that file, never the whole plan. - Implement. A fresh subagent, briefed with
implementer-prompt.md, asks questions if needed, implements, tests, commits and self-reviews. It reports one of four statuses: DONE, DONE_WITH_CONCERNS, NEEDS_CONTEXT or BLOCKED. It may not spawn subagents of its own, reviewers included. - Review.
scripts/review-packagewrites the commit list and diff to a file, and a fresh reviewer usingtask-reviewer-prompt.mdreturns two verdicts: spec compliance and code quality. Both are required. - Fix loop. A failed spec check or any Critical or Important finding starts the loop: up to five rounds, each a fix plus a scoped re-review. Minor findings are logged as deferred.
- Complete. A line goes in the ledger and the next task starts.
Final review. A reviewer on the most capable available model checks the whole branch. Its findings go to one fix subagent with the complete list, followed by one scoped re-review. The controller then lists every ruling it made in its final message and hands off to superpowers:finishing-a-development-branch.
Like executing-plans, it does not pause between tasks. It stops only for an irreversible or destructive operation, a security-sensitive action, a side effect outside the worktree such as a merge or push, or a plan so broken that every path forward is a guess. Everything else becomes a Ruling: line in the ledger.
What's in the folder:
SKILL.md: the process, model selection and a rationalizations table.implementer-prompt.md,task-reviewer-prompt.mdandre-review-prompt.md: the dispatch templates.references/:preflight.md,fix-loop.md,final-review.md,handling-reports.md,cannot-verify.md,batching.mdandresuming.md, each read at the step that needs it.scripts/:sdd-workspace,task-briefandreview-package, all bash.
How do you install it?
As part of Superpowers in Claude Code. The Superpowers README installs it from Anthropic's official marketplace:
/plugin install superpowers@claude-plugins-official
Plugin skills are namespaced as /plugin-name:skill-name per the Claude Code skills docs, so it shows up as /superpowers:subagent-driven-development. The README also documents the obra/superpowers-marketplace route and installs for Codex, Cursor, Gemini CLI and other agents.
Just this skill. The skills CLI can copy one folder, exactly as shown on the skills.sh page:
npx skills add https://github.com/obra/superpowers --skill subagent-driven-development
Add -g to install for all projects and -a claude-code to target Claude Code. The folder lands in .claude/skills/subagent-driven-development/ in your project, or ~/.claude/skills/subagent-driven-development/ with -g. Codex and Cursor read the same SKILL.md format; see Codex skills and Cursor skills.
A standalone copy still calls sibling skills: using-git-worktrees, requesting-code-review (its code-reviewer.md drives the final review) and finishing-a-development-branch. The plugin brings all of them. Because it relies on subagents, git and bash, it fits a coding agent rather than a ZIP upload to the Claude apps.
How do you use it?
You need a plan with mostly independent tasks and an agent that can dispatch subagents, such as Claude Code with its subagents. When writing-plans finishes, choosing "Subagent-driven" routes here. You can also call it directly.
Example prompts (suggestions, not quotes from the repo):
Execute docs/superpowers/plans/2026-10-24-invites.md with subagent-driven development./superpowers:subagent-driven-development docs/superpowers/plans/2026-10-20-search.mdResume the invites plan from its ledger and finish the remaining tasks.Run the plan, but use a cheap model for the mechanical tasks and the most capable one for the final review.
The skill's own decision chart is simple. No plan, or tightly coupled tasks: execute manually or brainstorm first. You chose inline, or there is no subagent tool: use executing plans. Otherwise, this skill.
Requirements: a subagent tool, a git repo, bash for the helper scripts, and your project's test runner.
How does it keep costs down?
Fresh subagents for every task and review add up, so the skill spends a full section on model choice:
| Role | Model the skill suggests |
|---|---|
| Mechanical task, 1 to 2 files, complete spec | A fast, cheap model |
| Multi-file integration or debugging | A standard model |
| Architecture, design and the final branch review | The most capable available model |
| Task reviews | Scaled to the diff's size, complexity and risk |
| Fix rounds 4 and 5 | At least one tier above the stuck implementer |
It also says to "Always specify the model explicitly" on every dispatch, because an omitted model inherits the session's, often the most expensive. And it notes that the cheapest models can take 2 to 3 times the turns on multi-step work, so a mid-tier model is the floor for reviewers.
Other savings: hand artifacts over as files rather than pasting them, never paste prior-task history into a dispatch, and batch several small same-shape edits into one subagent (references/batching.md).
Tips and limits
From the files, not from testing:
- Read the rulings. The controller decides conflicts and stuck findings for you. The final message lists every ruling with what it costs if wrong; that list is your review point.
- Sequential, not parallel. One implementer at a time. For independent problems you want solved concurrently, Superpowers has a separate
dispatching-parallel-agentsskill. - The controller doesn't fix code. Fixes go back to the implementer so they get reviewed. A controller fixing things itself is listed as a rationalization to avoid.
- Don't run
git clean -fdxmid-plan. It deletes the git-ignored workspace; the skill says to recover fromgit logif that happens. - What runs. The three bash helpers, your tests, and the subagents' own commands. Read the scripts first, like any script.
- License. MIT, so you can copy and edit the skill if you keep the copyright notice.
Save it in your Kipt library
In Kipt, open Skills and paste the skill's GitHub folder link into the import box. Kipt reads the SKILL.md and its files, including the three prompt templates, the references and the scripts; for a repo with many skills it shows a list to pick from, so you can take executing-plans and writing-plans too. You can also drop the folder or a .zip. Your skills live in your own private GitHub repo and install into Claude Code or Codex with one command:
npx skills add https://github.com/<you>/<repo>.git --all -g
Kipt is not affiliated with Jesse Vincent, Prime Radiant or Superpowers.
Similar skills
- Superpowers skills: the full workflow, from brainstorming to finishing the branch.
- Code review skill: Matt Pocock's review that also runs in parallel sub-agents.
- Claude Code subagents: how subagents work in Claude Code and how to define your own.
- Systematic debugging skill: the Superpowers process for bugs found along the way.