Superpowers: Makes coding agents develop with TDD and subagent workflows
Adds TDD, planning, and subagent review to coding agents instead of coding immediately.
GitHub obra/superpowers Updated 2026-09-04 Branch main Stars 294.5K Forks 26.3K
Shell JavaScript Python TypeScript Coding agents TDD Git worktrees Plugin ecosystem

🧭 Decision Guide

Try it if you

  • You use Claude Code, Codex CLI, or Cursor and want the agent to clarify the design before writing code.
    The README's “How it works” says the agent asks about the real goal, teases out a spec, and presents the design; “Installation” lists Claude Code, Codex CLI, and Cursor.
  • Your project requires RED-GREEN-REFACTOR, YAGNI, and DRY, and accepts task-based agent execution.
    The README's “How it works” and “Philosophy” explicitly emphasize true red/green TDD, YAGNI, and DRY; “Basic Workflow” includes test-driven-development and subagent-driven-development.
  • You need isolated branches, task-level plans, and code review workflows.
    The README's “Basic Workflow” lists using-git-worktrees, writing-plans, and requesting-code-review, and describes two review stages: spec compliance and code quality.

Skip it if you

  • Your coding agent is outside the Claude, Antigravity, Codex, Cursor, Devin, Factory, Gemini, Copilot, Grok, Kimi, OpenCode, and Hermes environments listed in the README.
    The README's “Installation” lists only these harnesses and states that installation differs by harness.
  • Your team does not accept mandatory TDD, planning, and code review workflows.
    The README's “Basic Workflow” explicitly says these are “mandatory workflows, not suggestions” and lists test-driven-development and requesting-code-review.
  • You rely on bootstrap persistence across long Hermes sessions and cannot restart sessions.
    The README's “Hermes Agent” says Hermes has no post-compaction hook; bootstrap can be lost when the first turn is compacted, requiring a fresh session.

Requirements

  • Installation differs by harness; if you use more than one harness, install Superpowers separately for each one.
  • Codex CLI requires opening the plugin search interface with `/plugins`.
  • Superpowers is installed through each coding agent's plugin or extension mechanism, such as `agy plugin install` for Antigravity and `gemini extensions install` for Gemini CLI.
  • Hermes requires active sessions to be restarted after installation; the README states that it has no post-compaction hook.
  • Visual companion telemetry can be disabled by setting `SUPERPOWERS_DISABLE_TELEMETRY` to any true value.

First step (verbatim from README)

agy plugin install https://github.com/obra/superpowers

Watch out

  • Do not skip a separate OpenCode installation just because Superpowers is installed in another harness.
    The README's “OpenCode” section explicitly says to install it separately even when another harness is already in use.
  • If skills stop triggering after compaction in a long Hermes session, start a fresh session.
    The README's “Hermes Agent” section says compaction beyond the first turn loses the bootstrap and requires a new session when skills stop triggering.
  • The visual companion defaults to loading the Prime Radiant logo from the website and includes the Superpowers version.
    The README's “Visual companion telemetry” section says the default resource comes from the website and includes the Superpowers version in use.

Not stated in the README

  • The README does not specify minimum versions for each harness.
  • The README does not provide a compatibility matrix for models or coding agents.
  • The README provides no benchmarks quantifying the effect of TDD or subagent-driven-development on development speed or cost.
  • The README does not explain recovery strategies for failed tasks, agent plan deviation, or unavailable subagents.
  • The README does not specify pricing, service levels, or data-handling terms for commercial enterprise support.
  • The README does not describe plugin permissions, execution isolation, or supply-chain security audit results.

💡 Deep Analysis

6
Yes I want to split a larger feature across multiple subagents using isolated Git worktrees; can Superpowers separately check specification compliance and code quality after each task?
For: A Git user who wants multiple subagents to work in parallel while requiring separate specification-compliance and code-quality reviews

Yes, because subagent-driven development, Git worktree isolation, and two-stage review are explicitly provided as a combined workflow in the README.

  • subagent-driven-development dispatches a relatively independent agent for each engineering task and inspects its work before continuing.
  • “The Basic Workflow” explicitly requires two review stages: specification compliance first, then code quality; critical issues block progress.
  • using-git-worktrees creates an isolated workspace and a new branch after design approval, which suits parallel work and reduces workspace contamination.
  • dispatching-parallel-agents is also listed in the Collaboration skills library. However, the README does not state the maximum parallelism, conflict-resolution mechanism, or how interface changes are shared across tasks.
  • The Basic Workflow: "subagent-driven-development ... two-stage review (spec compliance, then code quality)"
  • The Basic Workflow: "Critical issues block progress."
  • The Basic Workflow: using-git-worktrees creates an "isolated workspace on new branch"
  • What's Inside / Collaboration: dispatching-parallel-agents and subagent-driven-development
agy plugin install https://github.com/obra/superpowers
Not stated in the README:The README does not specify parallel subagent limits, model-call costs, or automatic Git conflict handling.;It does not define compatibility boundaries for initializing dependencies in multiple worktrees under complex build systems.
Yes I use both Claude Code and Codex CLI and want both hosts to clarify requirements, generate plans, and complete tasks with TDD and Git worktrees; is Superpowers suitable?
For: A coding-agent user who uses both Claude Code and Codex CLI and wants one workflow for requirements clarification, TDD, and Git branches

Yes, because it connects requirements, design, planning, implementation, review, and branch cleanup into one composable workflow, and it explicitly supports both Claude Code and Codex CLI.

  • The “Installation” section says that each harness must be installed separately, so both hosts can use it but one installation is not shared automatically.
  • “How it works” requires the agent to tease out a specification, present the design, and wait for approval before producing an implementation plan.
  • “The Basic Workflow” includes using-git-worktrees, writing-plans, test-driven-development, and requesting-code-review, matching your constraints.
  • This is a plugin and skills framework rather than a model. The README does not guarantee identical hook behavior, context limits, or subagent capabilities across hosts.
  • Installation: "If you use more than one, install Superpowers separately for each one."
  • How it works: "After you've signed off on the design, your agent puts together an implementation plan"
  • The Basic Workflow: using-git-worktrees, writing-plans, test-driven-development, and requesting-code-review
  • Project data: Shell, JavaScript, Python, TypeScript, and HTML are present; latest release v6.3.0
/plugin install superpowers@claude-plugins-official
Not stated in the README:The README does not state whether Claude Code and Codex CLI behave identically for subagents, session-start hooks, or context persistence.;It provides no cross-host success-rate, additional model-call, or execution-cost data.
It depends I maintain a legacy project with low test coverage and want to add tests incrementally while changing existing code with Claude Code; is Superpowers unsuitable because it requires tests first and deletes code written before tests?
For: A developer maintaining a legacy project with low test coverage who still wants a coding agent to use RED-GREEN-REFACTOR

It depends; if the legacy project has a runnable test baseline and can add tests incrementally, Superpowers can impose useful discipline, but it may create friction around untestable UI, infrastructure, or existing code without tests.

  • “The Basic Workflow” requires RED-GREEN-REFACTOR: write a failing test, confirm the failure, implement the minimum code, confirm the pass, and then commit.
  • The same section explicitly says “Deletes code written before tests,” so the agent may reject new code that was not test-driven.
  • The using-git-worktrees workflow runs project setup and verifies a clean test baseline, which requires a repeatable starting test state.
  • Project insights identify low-coverage legacy projects and difficult-to-test UI or infrastructure as sources of friction. The README provides no explicit legacy-project exception.
  • The Basic Workflow: "Enforces RED-GREEN-REFACTOR: write failing test, watch it fail, write minimal code, watch it pass, commit."
  • The Basic Workflow: "Deletes code written before tests."
  • The Basic Workflow: using-git-worktrees "runs project setup, verifies clean test baseline"
  • Project insights, common_pitfalls: TDD may conflict with legacy, low-coverage, hard-to-test UI, and infrastructure code
Not stated in the README:The README does not explain how to handle repositories that cannot establish a clean test baseline.;It does not identify which test frameworks, languages, or UI test types may be exempt from strict RED-GREEN-REFACTOR.
It depends I plan to deploy Superpowers through Claude Code in an enterprise environment where optional telemetry and remote plugin access must be controlled; does the README provide sufficient controls?
For: A security or platform engineer deploying Superpowers in an enterprise environment who needs to control remote resource loading and agent access

It depends; the README provides an explicit switch for Superpowers visual-companion telemetry, but that alone does not demonstrate enterprise-grade supply-chain, credential, or network isolation controls.

  • “Visual companion telemetry” says the default behavior loads the Prime Radiant logo with version information from a website, without project, prompt, or coding-agent details.
  • The same section provides SUPERPOWERS_DISABLE_TELEMETRY and says it honors Claude Code’s DISABLE_TELEMETRY and CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC opt-outs.
  • Installation through Claude’s official marketplace reduces the risk of an unknown source, but the README does not define enterprise approval, version pinning, or plugin-permission policies.
  • Project insights say sensitive environments should also review plugin origin, installation permissions, credentials, and file scope. Therefore, the environment variable alone is not a compliance decision.
  • Visual companion telemetry: "It does not include any details about your project, prompt, or coding agent."
  • Visual companion telemetry: `SUPERPOWERS_DISABLE_TELEMETRY`
  • Visual companion telemetry: honors `DISABLE_TELEMETRY` and `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC`
  • Installation / Claude Code: "official Claude plugin marketplace"
/plugin install superpowers@claude-plugins-official
Not stated in the README:The README does not say whether the plugin supports version pinning, offline installation, internal mirrors, or network allowlists.;It does not specify which credentials, files, or environment variables the agent can access by default across hosts.
It depends I mainly use Cursor Agent for small edits and configuration changes, usually wanting an immediate change to one file; will Superpowers make this workflow too heavy?
For: A Cursor Agent user who usually makes small direct edits and cannot accept a full design-approval workflow for every task

It depends; it fits medium or large development work, but it may be too heavy for the immediate small edits you describe because the project makes clarification, design approval, planning, and verification the default path.

  • “The Basic Workflow” activates brainstorming before code is written, then creates a worktree and plan after design approval.
  • writing-plans breaks work into 2–5 minute tasks, with exact file paths, complete code, and verification steps for each task.
  • “Philosophy” states “Test-Driven Development - Write tests first, always,” which may not fit a one-off configuration adjustment or a very short fix.
  • Project insights describe the framework as better suited to repository-based work with tests and Git branches. The README does not explain whether Cursor can bypass mandatory stages based on task type.
  • The Basic Workflow: "brainstorming - Activates before writing code"
  • The Basic Workflow: "writing-plans - Activates with approved design"; tasks are "2-5 minutes each"
  • Philosophy: "Test-Driven Development - Write tests first, always"
  • Project insights, usage_limitations: better suited to work with a repository, runnable tests, and Git branches
/add-plugin superpowers
Not stated in the README:The README does not say whether Cursor Agent can disable or shorten brainstorming, TDD, or worktree stages based on task size.;It does not quantify the extra interaction rounds or latency for a single-file change.
Yes I use Gemini CLI and want not only to adopt the existing TDD and systematic-debugging workflows but also to write team-specific skills; does Superpowers support that extension?
For: An advanced AI-programming user of Gemini CLI who wants to package the team’s testing and debugging rules as reusable skills

Yes, because the project provides reusable testing, debugging, and collaboration skills while also treating new-skill creation as a formal meta-skill workflow; Gemini CLI is listed among the supported hosts in the omitted README sections.

  • “What’s Inside / Skills Library” includes reusable skills such as test-driven-development, systematic-debugging, and verification-before-completion.
  • The Meta section includes writing-skills to “Create new skills following best practices,” including a testing methodology, which fits organizational rules.
  • “How it works” says skills trigger automatically, so the agent checks relevant skills when it recognizes development work rather than requiring a manual prompt each time.
  • However, the project is not an independent runtime or test platform. The README does not detail whether custom skills load consistently through Gemini CLI’s hooks, context limits, and plugin mechanisms.
  • What's Inside / Skills Library: test-driven-development, systematic-debugging, and verification-before-completion
  • What's Inside / Meta: "writing-skills - Create new skills following best practices"
  • How it works: "because the skills trigger automatically, you don't need to do anything special"
  • Omitted README sections: Gemini CLI is listed
Not stated in the README:The README does not provide a specific Gemini CLI installation command.;It does not document the directory structure, publishing method, version-compatibility rules, or Gemini CLI loading limits for custom skills.

✨ Highlights

  • Uses brainstorming to clarify requirements before producing design and implementation plans
  • test-driven-development enforces the RED-GREEN-REFACTOR cycle
  • subagent-driven-development dispatches agents per task with two-stage review
  • Supports multiple coding agents including Claude, Codex, Cursor, and Gemini

🔧 Engineering

  • Automatically triggers brainstorming, writing-plans, and TDD workflows
  • Uses using-git-worktrees to create isolated branches and verify the test baseline
  • Each engineering task can run in a fresh subagent with two-stage review

⚠️ Risks

  • Installation is harness-specific; multiple environments require separate Superpowers installs
  • Hermes lacks a post-compaction hook, so long sessions may lose the bootstrap
  • The optional visual companion defaults to loading a Prime Radiant telemetry resource

👥 For who?

  • Development teams using coding agents such as Claude Code, Codex, or Cursor
  • Engineering projects that want to enforce TDD, YAGNI, and DRY
  • Teams needing Git worktrees and subagents to handle engineering tasks