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.

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:

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.

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.

Superpowers is distributed through two marketplaces for Claude Code:

/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
/add-plugin superpowers

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

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

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.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.

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]

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.

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:

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.

Good fit:

Weaker fit:

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.

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.

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.