Superpowers Quickstart: Install, Workflow, and Tryout

Superpowers packages a full spec-driven methodology into installable Claude Skills, enforcing brainstorming, planning, subagent-driven implementation, and strict TDD instead of leaving that structure up to you.

Most Claude Code SDD setups fail the same way: someone writes a solid specify-plan-implement skill once, uses it diligently for a week, then quietly drifts back to unstructured prompting the first time a deadline gets close. Nothing in a hand-rolled skill actually stops that. Superpowers is a direct answer to that discipline problem -- a skills package built by Jesse Vincent and the team at Prime Radiant that treats brainstorming, planning, subagent review, and red-green-refactor TDD as mandatory steps the agent checks before every task, not optional suggestions it can skip under pressure.

What makes it worth a dedicated look rather than a footnote is the install story. Superpowers ships plugin manifests for Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot CLI, Grok Build CLI, Kimi Code, OpenCode, Pi, Devin CLI, Factory Droid, and Hermes Agent, so the same methodology follows you across harnesses instead of living in one repo's .claude/skills/ folder. This guide covers what it actually is, how to install and verify it on the agent you use, what a first end-to-end run looks like, and where it fits next to other spec-driven development tooling.

What Is Superpowers?

Superpowers describes itself as "a complete software development methodology for your coding agents, built on top of a set of composable skills and some initial instructions that make sure your agent uses them." That last clause is the part that matters. Plenty of skill collections exist; the differentiator here is the bootstrap instruction that forces the agent to check for relevant skills before starting any task, so the workflow activates automatically instead of requiring you to remember a slash command.

The philosophy behind it is stated plainly in the project's own docs:

• Test-Driven Development -- write tests first, always
• Systematic over ad-hoc -- process over guessing
• Complexity reduction -- simplicity as the primary goal
• Evidence over claims -- verify before declaring success

In practice, that philosophy shows up as a sequence of skills that hand off to each other. If you have read Claude Skills and SKILL.md for Developers, the mechanics will feel familiar -- Superpowers is a large, opinionated set of exactly that kind of SKILL.md directory, distributed as an installable plugin rather than something you author yourself.

Installing Superpowers Across Coding Agents

Installation is harness-specific, and the project is explicit that you install it separately for each agent you use -- there is no single global install.

Claude Code

Superpowers is distributed through two marketplaces for Claude Code:

# Official Anthropic plugin marketplace
/plugin install superpowers@claude-plugins-official

Or through the dedicated Superpowers marketplace, which also carries a few related plugins:

/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

Cursor

/add-plugin superpowers

You can also search "superpowers" directly in Cursor's plugin marketplace UI.

Other agents

A few install details are worth flagging before you run a real task:

• Antigravity runs the plugin's session-start hook automatically, so Superpowers is active from the first message; reinstall with the same command to update.
• Pi loads the skills through a small extension that injects the using-superpowers bootstrap at session startup and after context compaction, and does not require Pi's compatibility Skill tool since Pi has native skill support.
• Hermes Agent has no post-compaction hook -- a very long session that compacts over its first turn can lose the bootstrap, so start a fresh session if skills stop triggering.
• OpenCode treats this as a completely separate install path from any other harness you already use, even on the same machine.

Verify the install

Once installed, ask the agent directly rather than trusting a silent success message:

What skills are available?

If Superpowers installed correctly, the agent should list skills such as brainstorming, writing-plans, test-driven-development, and subagent-driven-development among the results. This is the same discovery check recommended for debugging Claude Skills that fail to trigger -- if the skill exists but never activates, the routing description is almost always the problem, not the model.

The Superpowers Workflow: Brainstorm to Shipped Code

Superpowers documents seven skills as "the basic workflow," each one activating at a specific point and handing off to the next:

flowchart LR
  A[brainstorming] --> B[using-git-worktrees]
  B --> C[writing-plans]
  C --> D{subagent-driven-development<br/>or executing-plans}
  D --> E[test-driven-development]
  E --> F[requesting-code-review]
  F --> G[finishing-a-development-branch]

1. brainstorming activates before any code gets written. It refines a rough idea through questions, explores alternatives, and presents the design in short, reviewable chunks rather than one long document -- then saves the result as a design artifact.
2. using-git-worktrees activates once you approve the design. It creates an isolated workspace on a new branch, runs project setup, and verifies a clean test baseline before implementation starts.
3. writing-plans breaks the approved design into bite-sized tasks -- Superpowers targets two to five minutes of work per task -- with exact file paths, complete code where relevant, and explicit verification steps.
4. subagent-driven-development (fast iteration) or executing-plans (batch execution with human checkpoints) dispatches a fresh subagent per task, with a two-stage review: spec compliance first, then code quality.
5. test-driven-development enforces strict red-green-refactor -- write a failing test, watch it fail, write the minimal code to pass, watch it pass, commit. Code written before a failing test existed for it gets deleted, not kept.
6. requesting-code-review activates between tasks, reviewing the diff against the plan and reporting issues by severity; critical issues block progress to the next task.
7. finishing-a-development-branch activates once all tasks complete. It verifies tests pass, then presents options -- merge, open a PR, keep the branch, or discard -- and cleans up the worktree.

This maps closely onto the tool-neutral five-phase loop in Spec-Driven Development Workflow From Requirements to Code: specify becomes brainstorming, plan becomes writing-plans, tasks and implement fold into subagent-driven-development, and validate is split across TDD and code review. The difference is enforcement -- Superpowers is built so the agent checks for these skills automatically rather than relying on you to invoke each phase.

Trying It Out: A First Task Walkthrough

Do not point Superpowers at your most important feature on the first run. Pick something real but bounded -- a small endpoint, a focused bug fix, a single module refactor -- and start a session in a project that already has a test suite, since TDD enforcement is most visible there.

I want to add rate limiting to our public API endpoints.

With Superpowers installed, expect the session to open with brainstorming questions rather than code: which endpoints, what limit, per-user or per-key, what should happen when the limit is hit. That friction is intentional -- it is the same non-goals discipline covered in Spec-Driven Development Workflow From Requirements to Code, just enforced by the skill rather than left to you to remember. Once you approve the design in chunks, expect a plan with numbered, small tasks before any file changes, then one subagent dispatched per task with a diff you review at each checkpoint.

Two things to watch on a first run:

• Confirm TDD is actually enforced. Ask the agent to implement one task and check whether a failing test appears before the implementation. If code lands first, the skill did not trigger for that step, and it is worth re-running the discovery check from the install section.
• Watch task granularity. The two-to-five-minute task sizing is aggressive for some codebases. If tasks feel needlessly fragmented for your project, that is worth raising during the writing-plans review checkpoint rather than after the fact.

What's Inside: The Skills Library

Beyond the seven workflow skills, Superpowers ships supporting skills grouped by area:

dispatching-parallel-agents is worth calling out separately: it covers concurrent subagent workflows, which is the same territory as Claude Code subagents -- isolated context, independent review, and a summary reported back to the main session instead of flooding it with intermediate output.

When Superpowers Fits (and When It Doesn't)

Good fit:

• You already like the Claude Code skills approach to Spec-Driven Development vs Vibe Coding but keep sliding back to unstructured prompting because nothing enforces the review gates.
• You work across multiple coding agents and want one methodology that travels with you instead of a Claude Code-only skill.
• You want strict TDD enforcement without writing the enforcement logic yourself.
• Multi-session features where architectural drift and forgotten constraints are a real risk -- the exact failure mode described in Spec-Driven Development vs Vibe Coding.

Weaker fit:

• Quick scripts, throwaway prototypes, and one-off automation -- the brainstorming and planning overhead is real, and it is not worth paying on a fifty-line change.
• Teams with an existing, well-tuned project-specific SDD skill. Superpowers trades that customization for enforced, opinionated ceremony; you may prefer to keep what already works and borrow only individual skill ideas.
• Environments where the strict two-to-five-minute task granularity or mandatory TDD would conflict with an established team process you are not ready to change.

How Superpowers Differs from Other SDD Tools

Superpowers is not a competitor to GitHub Spec Kit or AWS Kiro in the usual sense -- it operates at the Claude Code / cross-agent skills layer rather than as a standalone CLI or IDE. Spec Kit gives you portable markdown artifacts and agent independence; Kiro gives you a guided, integrated IDE experience; a hand-rolled Claude Code skill gives you maximum flexibility with zero enforcement. Superpowers sits between the last two: same skills-based mechanism as a DIY Claude Code workflow, but with mandatory-feeling enforcement and cross-agent plugin distribution that a repo-local skill does not provide.

For the full breakdown of portability, setup friction, review gates, and lock-in across Spec Kit, Kiro, Claude Code skills, OpenSpec, BMAD-METHOD, and Tessl -- including where Superpowers lands in the comparison table and decision framework -- see GitHub Spec Kit vs Kiro vs Claude Code SDD Workflows.

Troubleshooting and Things to Know

Updates are mostly automatic but agent-dependent. How current your install stays depends on the harness -- Antigravity re-runs the session-start hook on reinstall, npm- or Git-based installs need an explicit update command, and marketplace-based installs typically follow the host agent's own plugin update flow.

Telemetry is on by default but easy to disable. The brainstorming skill's optional visual companion loads the Prime Radiant logo from their website, which includes your Superpowers version but no project, prompt, or click data. Set SUPERPOWERS_DISABLE_TELEMETRY to any true value to turn it off. Superpowers also honors Claude Code's own DISABLE_TELEMETRY and CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC opt-outs.

Contributions require the dev branch. If you want to modify or add skills, fork the repository, switch to dev, and follow the writing-skills skill for creating and testing changes -- new skill contributions specifically are generally not accepted, since every skill must work identically across all supported agents.

If a skill does not trigger, treat it like any other Claude Skill problem. Ask "What skills are available?" to confirm discovery, check that you installed for the specific agent you are currently using (not a different one on the same machine), and remember that Hermes sessions need a fresh start after long-session compaction if the bootstrap silently drops.

Conclusion

Superpowers is worth installing when the gap between your SDD intentions and what actually happens in a session is the problem you are trying to solve. It does not introduce a new specify-plan-implement idea -- that loop is already well covered by What Is Spec-Driven Development? -- it makes an existing idea harder to skip, and it does that across more agents than a repo-local skill can reach. Install it on the one harness you use daily first, run a small bounded task through the full brainstorm-to-finish cycle, and decide from there whether the enforced ceremony earns its keep on your actual workload.

Useful Links

• Superpowers repository -- source, skills, and plugin manifests for every supported agent
• Superpowers marketplace -- Claude Code marketplace for Superpowers and related plugins
• GitHub Spec Kit vs Kiro vs Claude Code SDD Workflows -- full tool comparison and decision framework
• Claude Skills and SKILL.md for Developers -- the underlying skill mechanics Superpowers builds on
• Claude Code Subagents: Setup, Config, and When to Use Them -- isolated-context review, the mechanism behind subagent-driven-development
• Spec-Driven Development Workflow From Requirements to Code -- the tool-neutral five-phase process Superpowers automates
• What Is Spec-Driven Development? The Spec as Source of Truth -- core SDD concepts and terminology
• Claude Code install and config for Ollama, llama.cpp, pricing -- install Claude Code itself before adding Superpowers