Guide · Agent skill
How to use the Subagent-Driven Development agent skill
Updated · written with AI from the project's own documentation and checked against our catalogue data
Subagent-Driven Development is an agent skill that tells an AI agent how to carry out a written implementation plan by handing each task to a fresh sub-agent, then reviewing the result before moving on. It suits developers who have a multi-step plan with mostly independent tasks and want it done in one session with review checkpoints. After this guide you will know how to install the skill, how to ask for it in plain language, and what it needs and does while it runs.
Subagent-Driven DevelopmentjnMetaCode/superpowers-zh · MIT Download the skill Quick start
- 1Confirm the prerequisites. Make sure the project is a Git repository, bash is available, your agent supports sub-agents, and the four referenced skills are installed.
- 2Install the skill. Download the ZIP from this page and unzip it into ~/.claude/skills/ for personal use or into the project's .claude/skills/ folder, or upload it under Settings → Capabilities → Skills in the Claude apps.
- 3Write or pick a plan file. Have a written implementation plan with mostly independent tasks. Tightly coupled work is better done manually or with executing-plans.
- 4Ask for the skill in plain language. Name your plan file and ask the agent to execute it with subagent-driven development, with a fresh sub-agent per task and review after each one.
- 5Let the agent set up the workspace. The agent runs bash scripts/sdd-workspace PLAN_FILE and creates a ledger whose first line names your plan.
- 6Review the ledger and final result. Check the progress ledger for completed tasks and recorded rulings, then review the final output and the finishing steps.
What the skill makes the agent do
When the skill is active, the agent gives each task in your plan to a new implementation sub-agent with its own clean context. After each task, a task reviewer checks spec compliance and code quality. When all tasks are finished, a broader reviewer looks at the whole branch once more.
The skill keeps a progress ledger file so work can resume after the context is compacted. It also sets rules for choosing cheaper or stronger models per task, and tells the agent to keep going between tasks instead of stopping to ask you. When a conflict or ambiguity comes up, the agent makes a ruling, records it in the ledger, and continues. It only stops for a small set of cases: irreversible or destructive actions, security-related actions, side effects outside the worktree that normally need permission (merging, pushing to a shared branch, publishing), and a plan so flawed that every way forward is a guess.
- One fresh sub-agent per task, so context does not carry over between tasks
- Spec compliance and code quality review after each task
- A final review across the whole branch
- A progress ledger file that records completed tasks and rulings
- Model choice per role, with the model always set explicitly
Install the skill
You can install the skill in either of two ways. Download the ZIP from the skill's page on this site and unzip it into one of these locations:
For a personal skill available across your projects, unzip it into ~/.claude/skills/. For a single project, unzip it into that project's .claude/skills/ folder.
In the Claude apps, you can instead upload the skill under Settings → Capabilities → Skills.
- Personal: ~/.claude/skills/
- Project only: .claude/skills/ inside your project folder
- Claude apps: Settings → Capabilities → Skills (upload)
Check the requirements before you start
The skill assumes a few things are already in place. Your project must be a Git repository, because the skill uses git worktrees, git log and a git-ignored workspace directory. The bundled script runs under bash. Your agent platform must also support sub-agents, since the skill is explicitly not meant for environments without them.
The skill refers to other skills that must also be installed: using-git-worktrees, executing-plans, requesting-code-review and finishing-a-development-branch. Without them, the referenced steps will not be available.
- A Git repository
- bash, to run the bundled scripts/sdd-workspace script
- A sub-agent capability in the host agent platform
- Also installed: using-git-worktrees, executing-plans, requesting-code-review, finishing-a-development-branch
Trigger the skill with a natural request
You do not need a special command. The skill is meant for a situation where you already have a written implementation plan with mostly independent tasks and want the agent to execute it in the current session. Describe that situation in plain language and point the agent at your plan file.
The skill is not the right choice for tightly coupled work. In that case the skill itself says to brainstorm or work manually, and for a session where you prefer inline execution, the executing-plans skill is the alternative.
- Ask the agent to execute your plan file using subagent-driven development, naming the file
- Ask for each task to be handled by a fresh sub-agent with review after each task
- Ask the agent to run the plan through to the end without stopping between tasks
Run the workspace script and follow the ledger
When the skill starts, the agent runs the bundled script against your plan file. The script prints a plan-specific, git-ignored directory under <repo-root>/.superpowers/sdd/, where the ledger, briefs, reports and review packages for that plan are stored. The ledger's first line names the plan file. Each task marked complete in the ledger is not re-dispatched, so an interrupted run resumes from the first unfinished task.
The agent also checks your plan for conflicts before starting task 1, and it writes the results to the ledger. If you find that a ledger belongs to a different plan, the skill says to leave it alone and start a new one.
bash scripts/sdd-workspace PLAN_FILEUse it for the right kind of work
Good fits are plans where each task touches one to two files and has a clear spec, or where you want review checkpoints across a multi-step change. Poor fits are tightly coupled tasks, or any case where you want to approve every decision yourself, because the agent is told to rule on conflicts itself and a wrong guess can mean rework.
Small, same-shaped changes spread across files, such as the same one-line fix in several places, can be batched into a single brief for one sub-agent instead of one sub-agent per task.
- Good: independent tasks in a written plan, executed in one session
- Good: small repeated changes, batched into one brief
- Poor: tightly coupled tasks
- Poor: work where you must approve each decision
What people use it for
- Executing a multi-step feature plan where each task touches one or two files and can be built separately.
- Batching a repetitive change, such as the same field addition across many files, into one sub-agent brief.
- Resuming an interrupted plan after context compaction, using the ledger and git log to pick up at the first unfinished task.
- Running a plan end to end in one session with review after each task and a whole-branch review at the end.
Frequently asked questions
How do I install the subagent-driven-development skill?
Download the ZIP from this skill's page and unzip it into ~/.claude/skills/ for personal use, or into a project's .claude/skills/ folder for one project. In the Claude apps, you can upload it under Settings → Capabilities → Skills.
Is subagent-driven-development free to use?
The skill is released under the MIT licence, as stated in its metadata. The source does not mention pricing, but running sub-agents costs model usage on your platform, and the skill's model rules are written to reduce that cost.
What does subagent-driven-development require?
It requires a Git repository, bash to run the bundled sdd-workspace script, and a sub-agent capability in your agent platform. It also needs the skills using-git-worktrees, executing-plans, requesting-code-review and finishing-a-development-branch to be installed.
Does the skill use the network or run scripts?
It runs bundled scripts, including scripts/sdd-workspace and scripts/task-brief, and the source lists it as running scripts. It is listed as not using the network. The workspace is a git-ignored directory, and the skill warns that git clean -fdx would destroy it.
What is the difference between this and executing-plans?
Executing-plans runs the plan inline in one context. Subagent-driven-development gives each task a fresh sub-agent and reviews after each task, which adds isolated context and checkpoints but uses more contexts. The skill itself says to use executing-plans when the partner chooses inline execution or no sub-agent tool is available.
Why does the agent keep going instead of asking me questions?
The skill tells the agent to continue through tasks without confirmation and to make rulings on conflicts itself, recording each one in the ledger. If it guesses wrong, the cost is rework you can see and undo. You should not use this skill if you want to approve every decision.
New agent skills, repos and AI tools — every week
The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.
Our verdict
Use subagent-driven-development if you have a written multi-step plan with mostly independent tasks and want it run in one session with review checkpoints and a resumable ledger. Pick executing-plans or manual work if your tasks are tightly coupled, if you want to approve each decision, or if your environment has no sub-agent support.
Download the skill