Skip to content
Superpowers

Superpowers Skill

by Jesse Vincent obra/superpowers

An agentic software-development methodology: composable skills that push a coding agent through spec, plan, TDD and review instead of straight into code.

GitHub Docs
Featured Development
Released
MIT
73 views

Install

Install with the skills CLI

One command for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf and dozens of other agents. Needs Node.js; the skill is fetched straight from obra/superpowers.

$ npx skills add obra/superpowers

Run it in a terminal. The CLI finds the agents installed on your machine, asks which ones to add the skill to, and whether to install it into the folder you ran it from or for all your projects. It also lists the skills in the repository so you can pick Superpowers.

Other ways to install

  1. Open the skill on GitHub and download the folder that holds its SKILL.md.
  2. Put it at ~/.claude/skills/superpowers/, where Claude Code picks it up in every project.

No scripts or references next to it? Saving the SKILL.md alone as ~/.claude/skills/superpowers/SKILL.md works too.

Using another agent? Its personal skills folder
Codex
~/.agents/skills/
Cursor
~/.cursor/skills/
GitHub Copilot
~/.copilot/skills/
Gemini CLI
~/.gemini/skills/
Windsurf
~/.codeium/windsurf/skills/
OpenCode
~/.config/opencode/skills/
Open folder on GitHub

About

  • Brainstorming skill that extracts a reviewable spec before any code is written
  • Plans broken into 2-5 minute tasks with exact file paths and verification steps
  • Subagent-driven development with two-stage review per task
  • Enforced RED-GREEN-REFACTOR TDD that deletes code written before its test
  • Every run isolated in its own git worktree against a clean test baseline
  • Automatic skill triggering - no commands to remember
  • Installable on 14+ harnesses including Claude Code, Cursor, Codex and Gemini CLI

Superpowers is the most-installed agent skills framework on GitHub, and it is less a single skill than an opinionated development process that a coding agent is made to follow.

The premise is that the failure mode of coding agents is not writing bad code, it is writing the wrong code confidently. So the moment the agent notices you are building something, it does not start typing. It steps back and interrogates the idea, teases a specification out of the conversation, and shows it back to you in chunks short enough to actually read and sign off on.

From an approved design it writes an implementation plan broken into tasks of two to five minutes each, with exact file paths, complete code and verification steps — deliberately written to be followable by "an enthusiastic junior engineer with poor taste, no judgement, no project context, and an aversion to testing." Then it runs subagent-driven development: a fresh subagent per task, each reviewed twice, first for spec compliance and then for code quality, with critical issues blocking progress. Test-driven development is enforced rather than suggested — RED-GREEN-REFACTOR, and code written before its test gets deleted.

Two structural choices make the whole thing work. Every piece of work happens in its own git worktree with a verified-clean test baseline, so a long autonomous run cannot quietly corrupt your main checkout. And the skills trigger automatically from context, so there is no command to remember; the agent simply behaves differently. Runs of a couple of hours without deviating from the agreed plan are reported as routine.

It is genuinely harness-neutral. Alongside Claude Code, the project documents installation for Cursor, Codex CLI and the Codex app, Gemini CLI, GitHub Copilot CLI, Devin CLI, Antigravity, Factory Droid, Grok Build CLI, Kimi Code, OpenCode, Pi and Hermes Agent — install it separately per harness if you use more than one.

MIT licensed and maintained by Jesse Vincent and the team at Prime Radiant, who also offer commercial support for enterprise use. Companion repositories carry experimental skills (superpowers-lab) and community-editable ones (superpowers-skills).

Best suited to people who want an agent to work autonomously for long stretches and are willing to spend ten minutes on a spec up front to get it. Overkill for one-line fixes.

Try it

Once installed, ask your agent something like:

Just describe what you want to build. Superpowers activates on its own:

Let's build a rate limiter for the API.

The agent will start by asking questions rather than writing code, present a design for approval, write a task-level plan, then execute it in a git worktree under TDD with review between tasks.

SKILL.md

The instructions your agent loads, as published by Jesse Vincent.

SKILL.md

Superpowers

Superpowers is a complete software development methodology for coding agents, built on composable
skills plus the initial instructions that make sure the agent actually uses them.

The agent checks for a relevant skill before any task. These are mandatory workflows, not suggestions.

The workflow
  1. brainstorming - Activates before writing code. Refines rough ideas through questions, explores

alternatives, presents the design in sections short enough to actually read. Saves a design document.

  1. using-git-worktrees - Activates after design approval. Creates an isolated workspace on a new

branch, runs project setup, verifies a clean test baseline.

  1. writing-plans - Activates with an approved design. Breaks work into bite-sized tasks of 2-5

minutes each. Every task has exact file paths, complete code and verification steps.

  1. subagent-driven-development / executing-plans - Dispatches a fresh subagent per task with

two-stage review (spec compliance, then code quality), or executes in batches with human checkpoints.

  1. test-driven-development - Enforces RED-GREEN-REFACTOR: write a failing test, watch it fail,

write minimal code, watch it pass, commit. Deletes code written before its test.

  1. requesting-code-review - Activates between tasks. Reviews against the plan and reports issues by

severity; critical issues block progress.

  1. finishing-a-development-branch - Verifies tests, presents merge/PR/keep/discard options, cleans

up the worktree.

Philosophy

Plans should be clear enough for an enthusiastic junior engineer with poor taste, no judgement, no
project context and an aversion to testing to follow. The methodology emphasises true red/green TDD,
YAGNI and DRY.

Install

Related Skills

See all Superpowers alternatives

Skill: Planning with Files

by OthmanAdi

File-based planning for long-running agent tasks — crash-proof markdown plans that survive /clear and compaction, with per-turn re-injection and a deterministic completion gate.

Development
Browse all skills →