Source: obra/superpowers · Maintainer: community: Jesse Vincent (Prime Radiant) · License: MIT · Checked: 24 October 2026
What is the dispatching parallel agents skill?
The dispatching parallel agents skill tells a coding agent to split independent problems, such as test failures in unrelated files, across several subagents that work at the same time. Each subagent gets one narrow problem and a self-contained brief, and the main agent reviews and integrates what comes back.
It ships in Superpowers, the open source skill library by Jesse Vincent and Prime Radiant, where the README lists it as "Concurrent subagent workflows". The skill's description reads: "Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies".
Its core principle: "Dispatch one agent per independent problem domain. Let them work concurrently." As of 24 October 2026, its skills.sh page listed about 218,200 installs (snapshot, 24 October 2026).
What does it do?
The folder holds one file, SKILL.md. It triggers when there are two or more independent tasks. Its examples are mostly debugging: three or more test files failing with different root causes, or several subsystems broken independently.
The starting idea is about context. Subagents should never inherit the main session's history; the coordinator writes exactly what each one needs, which also keeps its own context free for coordination.
The four steps
- Identify independent domains. Group failures by what's broken. The skill's example: one file tests tool approval, another batch completion, a third abort handling. Fixing one doesn't affect the others.
- Write focused agent tasks. Each subagent gets a specific scope (one test file or subsystem), a clear goal (make these tests pass), constraints (don't change other code) and an expected output (a summary of what it found and fixed).
- Dispatch in parallel. All dispatches go out in the same response. The skill spells out the mechanic: "Multiple dispatch calls in one response = parallel execution. One per response = sequential."
- Review and integrate. Read each summary, check that the fixes don't conflict, run the full test suite, then integrate.
What a good brief looks like
The skill says a good agent prompt is focused on one problem domain, self-contained, and specific about what to return. Its sample brief names the failing test file, lists the three failing tests with what each expects, suggests the likely cause (timing and race conditions), and ends with a constraint ("Do NOT just increase timeouts - find the real issue.") and a return format.
It also lists four common mistakes, each with the fix:
| Mistake | Better |
|---|---|
| Too broad: "Fix all the tests" | One file or subsystem per agent |
| No context: "Fix the race condition" | Paste the error messages and test names |
| No constraints | Say "Do NOT change production code" or "Fix tests only" |
| Vague output: "Fix it" | Ask for the root cause and the changes made |
When it says not to parallelize
The skill is as clear about when to skip it: failures that are related (fixing one might fix the rest), problems that need the whole system in view, exploratory debugging when you don't yet know what's broken, and shared state, where agents would edit the same files or use the same resources.
After agents return, its verification list ends with a spot check, because "Agents can make systematic errors."
How do you install the dispatching parallel agents skill?
As part of Superpowers in Claude Code. The README's install section 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 appears as /superpowers:dispatching-parallel-agents. 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 copies one folder, as shown on the skills.sh page:
npx skills add https://github.com/obra/superpowers --skill dispatching-parallel-agents
Add -g to install for all projects. The folder lands in .claude/skills/dispatching-parallel-agents/ in your project, or ~/.claude/skills/dispatching-parallel-agents/ with -g. Codex and Cursor read the same SKILL.md format; see Codex skills and Cursor skills.
How does it compare with subagent driven development?
Both Superpowers skills hand work to subagents with crafted context. They solve different problems.
dispatching-parallel-agents |
subagent-driven-development |
|
|---|---|---|
| Input | Two or more independent problems | A written implementation plan |
| Order | All at once | One task at a time |
| Parallel implementers | Yes, one per problem domain | Never, because they would conflict |
| Review | Coordinator reads summaries, checks conflicts, runs the full suite | Reviewer subagent after every task, plus a final whole-branch review |
| Files | SKILL.md only | SKILL.md, prompt templates, references, scripts |
Use subagent driven development to build a feature from a plan. Use this skill when a refactor or upgrade leaves several unrelated things broken and you want them fixed at once.
In Claude Code, the subagent mechanics come from the tool itself. The subagents docs say each subagent runs in its own context window, and give a parallel research example. Our Claude Code subagents guide covers setup.
How do you use it?
The skill fits best after a change that breaks several unrelated things. You can describe the failures and let it trigger, or name it.
Example prompts (suggestions, not quotes from the repo):
Six tests fail across three files after the refactor. Use dispatching-parallel-agents: one agent per file, tests only, no production changes./superpowers:dispatching-parallel-agents The payments, search and email modules each have a separate failing integration test. Fix them in parallel and report root causes.Investigate the lint errors in packages/api and the type errors in packages/web in parallel. They don't share code.Before you split this up, check whether these failures are related. If they are, investigate them together.
Requirements: an agent that can dispatch subagents and a test suite to run after integration. No packages, keys or scripts come with the skill.
Tips and limits
From the files, not from testing:
- Independence is the whole test. If two agents might touch the same file, the skill says don't run them in parallel.
- Agents share one working tree. The skill's protection is scope and constraints. If you need stronger isolation, Claude Code can run sessions in separate git worktrees; see our worktrees guide.
- Parallel work still costs tokens. Each subagent sends its own requests, which the Claude Code docs say count toward the same usage limits as the main conversation.
- Always run the full suite after. Fixes that pass alone can still conflict.
- No scripts run. The skill is instructions only.
- Audits. As of 24 October 2026, skills.sh showed Pass from Gen Agent Trust Hub, Socket and Snyk.
- License. Superpowers is 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; for a repo with many skills it shows a list to pick from, so you can take systematic-debugging in the same import. 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
- Subagent driven development skill: sequential subagents for a written plan, with review after each task.
- Systematic debugging skill: find the root cause first when you can't yet tell whether failures are related.
- Requesting code review skill: a reviewer subagent with crafted context, for checking the integrated result.
- Using git worktrees skill: isolated workspaces for parallel branches.