Dev & Engineering workflowsubagentsparallelismsuperpowers

Dispatching Parallel Agents

Fan out 2+ genuinely independent tasks to parallel subagents in one shot instead of queuing them sequentially

FollowSkills review · FSRS-1.0
Not recommended
58/ 100
Utility17 / 20

The purpose is clear: dispatch one specialized agent per independent problem domain to reduce serial investigation time when tasks have no shared state or sequential dependency. The skill defines use cases, non-use cases, scope, and expected outputs, giving it practical value for coding-agent users. Evidence gaps include no quantified benefit and no guidance on agent-count limits, concurrency capacity, or more granular boundaries for when parallelization is inappropriate.

Reliability11 / 20

The workflow covers identifying independent domains, creating self-contained prompts, dispatching concurrently, reviewing results, checking conflicts, and running the full test suite. These steps support some consistency and reproducibility. Evidence gaps are the absence of executable tests for this skill, retry or timeout handling, and detailed runtime assumptions; the successful example cannot be independently verified during static review.

Safety13 / 25

The skill requires isolated context, constrained scope, avoidance of unrelated edits, and post-dispatch review plus full-suite verification. These controls reduce context leakage and unconstrained changes. However, it does not specify agent permissions, limits on file writes, command execution, network access, or sensitive-data flows, and it lacks consent, cancellation, rollback, resource quotas, and recovery procedures for concurrent conflicts. No malware, credential theft, covert exfiltration, or destructive default sufficient for a red-line finding was identified.

Evidence6 / 15

The decision graph, concrete prompt template, anti-patterns, and verification checklist provide traceable documentation for the proposed method. However, the “Real Example from Session” and “Real-World Impact” sections provide only narrative claims, with no logs, test artifacts, commits, or independent corroboration. Facts, experiential inferences, and measurable outcomes are not clearly separated, so evidence strength is limited.

Usability7 / 10

The use and non-use sections help users determine applicability, and the prompt structure clearly specifies scope, goal, constraints, and output. The integration section also supplies final checks. Evidence gaps include no platform-compatibility guidance, concurrency-cost information, failure diagnostics, standard output for cancellation or partial completion, or concrete handling for insufficient resources, agent conflicts, or uncertain independence.

Maintenance4 / 10

The repository supplies an MIT license, a fixed assessment revision, and repository context identifies package version 6.1.1; these are mostly repository-level rather than skill-specific maintenance signals. Publisher identity is unverified, and the skill has no version, changelog, maintainer, release responsibility, or explicit update-response path. Maintenance and governance support are therefore limited.

Evidence confidence:Low Reviewed Jul 15, 2026 Reviewed revision d884ae04edeb
Before you use it
  • Dispatch in parallel only after independently confirming that tasks have no shared state, sequential dependency, or common editing resource.
  • Concurrent agents may edit the same files or contend for tests, ports, and external resources; establish workspace isolation, permission boundaries, and resource quotas before use.
  • The “Real Example from Session” and “Real-World Impact” claims lack independently verifiable tests or logs and should not be treated as validated performance or success-rate evidence.
  • The skill does not define cancellation, timeout, retry, rollback, or partial-failure handling; do not assume that a final full-suite run makes concurrent changes safely recoverable.
Review evidence [1][2][3][4][5][6][7]
See the full review method →

What it does & when to use it

Teaches Claude to recognize when multiple independent problems (e.g. three unrelated test files failing for different reasons) can be split into non-interfering subagent tasks and dispatched together, in parallel, instead of investigated one at a time. Each subagent gets a precisely constructed, isolated context — it never inherits the main session's history — which avoids cross-contamination and preserves the coordinator's own context budget.

First checks whether the problems are truly independent (no shared state, no sequential dependency); groups failures by problem domain (e.g. by test file or subsystem); writes each subagent a focused scope, goal, constraints, and expected output format; issues multiple subagent dispatches in the same response for real parallelism (splitting across messages makes it sequential instead); after agents return, reads each summary, checks for conflicting edits, and runs the full test suite to confirm everything integrates cleanly.

  1. Three unrelated test files start failing after one change, for three different root causes — dispatch three subagents in parallel
  2. A refactor breaks several subsystems independently with no shared state between them — investigate them concurrently
  3. Offload context-hungry investigation work to isolated subagents to keep the main session's context free for coordination

Pros & cons

Pros
  • Gives explicit criteria for when parallel dispatch is safe vs. when work should stay sequential (shared state, dependencies) — not blind parallelism
  • Provides a concrete agent-prompt template (scope, goal, constraints, expected output) that reduces subagents going off-track
  • Includes a full real debugging-session case study (6 failures split into 3 parallel fixes) that's directly reusable as a pattern
Limitations
  • Only reliably self-enforcing on harnesses that actually read and follow SKILL.md instructions (Claude Code, Codex CLI, etc.) — in a plain chat interface it's just a document a human has to apply by hand.
  • If the independence judgment is wrong (a hidden dependency existed), parallel execution can produce conflicts that need manual reconciliation
  • Requires a harness that actually supports subagent/concurrent task dispatch — not useful in a plain single-threaded chat tool

How to install

Installed as part of the obra/superpowers plugin — individual skills can't be installed standalone:

  1. Claude Code: official marketplace /plugin install superpowers@claude-plugins-official; or register the community marketplace with /plugin marketplace add obra/superpowers-marketplace then /plugin install superpowers@superpowers-marketplace
  2. Also supports Antigravity, Codex App/CLI, Cursor, Factory Droid, GitHub Copilot CLI, Kimi Code, OpenCode, and Pi — see the repo README for the exact command per harness

Once installed, this skill activates alongside the other 13 Superpowers skills, auto-triggered by using-superpowers based on context — there's no separate invocation step.

How to use

Automatically considered when a task surfaces multiple clearly independent problems. Typical pattern: Claude issues three subagent dispatches in the same response — "fix test file A", "fix test file B", "fix test file C" — running them concurrently.

Compared to similar skills

Compared to leaving the model to decide on its own whether to parallelize, this skill turns "when to parallelize," "how to write the subagent prompt," and "how to integrate results afterward" into explicit checklist items — reducing both reckless parallelism that causes conflicts and missed parallelism that wastes time running things sequentially.

FAQ

What's the difference between dispatching in one response vs. several messages?
The SKILL.md is explicit: multiple subagent dispatches issued in the same response run in parallel; splitting them across messages makes them sequential — this is the detail that actually determines whether you save time.

More skills from this repository

All from obra/superpowers

Dev & Engineering

Test-Driven Development (TDD)

Iron rule: no production code without a failing test written first — code written out of order gets deleted and restarted, no "tests added after"

Dev & Engineering

Brainstorming (Requirements & Design)

Forces requirement clarification before any code gets written — hard-blocks implementation until a design is approved

Dev & Engineering

Verification Before Completion

No claim of "done" or "tests pass" without fresh evidence from actually running the check — including hedges like "should" or "looks like"

Dev & Engineering

Finishing a Development Branch

Verifies tests pass, then walks you through a fixed merge/PR/keep/discard menu and cleans up worktrees by strict ownership rules

Dev & Engineering

Receiving Code Review

Bans performative agreement like "you're absolutely right!" — requires verifying feedback before implementing or pushing back

Dev & Engineering

Requesting Code Review

Dispatches a reviewer subagent with isolated context to check your changes, instead of self-grading in the same session that wrote them

Dev & Engineering

Systematic Debugging

Requires completing root-cause investigation before proposing any fix — explicitly bans "just try changing this and see"

Dev & Engineering

Writing Plans

Breaks requirements into 2-5-minute tasks an implementer with zero codebase context could follow verbatim — bans placeholders like "TBD" or "fill in details"

Dev & Engineering

Subagent-Driven Development

Dispatches a fresh implementer subagent per task in the same session, with two-stage review and a progress ledger that survives context compaction

Dev & Engineering

Executing Plans

Batch-executes an already-written implementation plan with human checkpoints, for sessions without subagent support

Dev & Engineering

Using Git Worktrees

Prefer the platform's native isolation tool before starting new feature work; fall back to manual git worktrees only when no native tool exists

Dev & Engineering

Writing Skills (Authoring & Testing Skills)

Applies TDD's red-green-refactor to writing skill documentation itself — expose real failure modes with a no-skill baseline test first, then write targeted guidance instead of guessing

Dev & Engineering

Using Superpowers (Bootstrap)

The entry-point skill for the whole Superpowers system — mandates invoking a relevant skill whenever there's even a 1% chance it applies

Related skills