subagent-driven-development
Subagent-Driven Development
Subagent-Driven Development is an agent skill from Superpowers: your agent carries out a plan by giving each task to a fresh subagent, reviewing every task, then reviewing the whole branch.
Install Subagent-Driven Development
In Claude Code, install the whole Superpowers plugin from Anthropic's official marketplace
/plugin install superpowers@claude-plugins-officialOr install only this skill with the skills CLI
npx skills add obra/superpowers --skill subagent-driven-developmentOr paste this into your coding agent: Install the agent skill subagent-driven-development from github.com/obra/superpowers.
A skill can include scripts that run on your computer, so read its source first.
What Subagent-Driven Development does
Subagent-Driven Development is one of the skills in Superpowers, Jesse Vincent's open-source method for AI coding agents. It loads when the agent executes an implementation plan whose tasks are mostly independent. The main agent acts as a controller: a fresh implementer subagent takes each task, a task reviewer checks spec compliance and code quality after it, and a reviewer on the most capable available model checks the whole branch at the end.
Subagent-Driven Development's bundled scripts set up a git-ignored workspace per plan, cut each task's brief out of the plan, and package the diff for the reviewer as a file. Progress goes into a ledger that survives context compaction, so a controller that loses its place does not redo finished tasks. Review findings go through fix rounds, at most five per task: the first three resume the same implementer, the last two use a fresh one on a more capable model.
In Subagent-Driven Development, each role gets the least capable model that can handle it, and every dispatch names its model. The agent runs all tasks without checking in, records its own rulings on plan conflicts, and stops only for destructive or security-sensitive actions, a merge, push or publish, or a plan too broken to follow. It works in a worktree from Using Git Worktrees, takes its final reviewer from Requesting Code Review, and ends with Finishing a Development Branch.
When to use Subagent-Driven Development
- You have a plan with many independent tasks and want each one reviewed before the next starts.
- Your agent loses track of long plans after its context is compacted.
- You want to keep cost down by running simple tasks on cheaper models.
- You want the agent to work through the whole plan without asking whether to continue.
When to pick something else
- Your agent has no subagent tool, or you want one context to do every task: use Executing Plans.
Which agents Subagent-Driven Development works in
Jesse Vincent documents Subagent-Driven Development for Claude Code, Codex (app and CLI), Cursor, Gemini CLI, GitHub Copilot CLI, OpenCode, Antigravity, Devin CLI, Factory Droid, Grok Build CLI, Kimi Code, Pi, Qwen Code, Hermes Agent, Muse. The open skills CLI also installs it into 78 agents, including Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode (we listed it with the CLI on October 1, 2026). See where each agent looks for skills.
Superpowers is written in Claude Code's vocabulary (subagent dispatch, todos, the Skill tool) and ships tool mappings for Codex, Gemini CLI, Pi, Antigravity, Hermes Agent and Muse. Installed as the full plugin, a session-start hook loads Using Superpowers so the agent reaches for skills on its own; one skill installed with the skills CLI gets no hook and may point to sibling skills you do not have. This skill needs a subagent tool: Claude Code's Agent tool, or in Codex the multi-agent feature switched on in config.toml (multi_agent = true).
Subagent-Driven Development license
Subagent-Driven Development is published under MIT.
Related skills for planning and agent workflow
- Grill me: grill-me is Matt Pocock's agent skill that turns your agent into a relentless interviewer, asking numbered rounds of questions about a plan or design until every decision is settled.
- Brainstorming: Brainstorming is an agent skill from Superpowers that makes your coding agent work out what you want and agree a design with you before it writes any code.
- Diagnosing Superpowers: Diagnosing Superpowers is an agent skill from Superpowers that reads a session's transcripts when work went wrong and reports what happened, with every finding tied to a file and line.
- Dispatching Parallel Agents: Dispatching Parallel Agents is an agent skill from Superpowers: when several problems are independent, your agent sends a focused subagent to each at once, then checks the results together.
More from Jesse Vincent
- Executing Plans: Executing Plans is an agent skill from Superpowers in which your agent works through a written plan itself, task by task with tests, then gets one fresh review of the whole branch.
- Finishing a Development Branch: Finishing a Development Branch is an agent skill from Superpowers: when work is done, your agent runs the tests, offers to merge, open a pull request or keep the branch, then cleans up.
- Receiving Code Review: Receiving Code Review is an agent skill from Superpowers: your agent checks review feedback against the code before acting, pushes back with reasons when it is wrong, and skips the flattery.
- Requesting Code Review: Requesting Code Review is an agent skill from Superpowers: your agent sends its changes to a separate reviewer subagent that checks them against the plan and grades each issue by severity.