Superpowers: AI Coding Agent Skills

1. Project Overview

Superpowers is an open-source software development methodology for AI coding agents — a composable library of "skills" that guides tools like Claude Code, Cursor, and Codex CLI through a disciplined, evidence-driven workflow instead of letting them jump straight into ad-hoc coding.

2. Background & Positioning

Superpowers was created to solve a common failure mode of AI coding agents: writing code first and thinking later, skipping design review, skipping tests, and declaring tasks "done" without real verification. Its core mission is to give agents a repeatable, professional-grade process — brainstorming, planning, isolated execution, test-driven development, and code review — so that agent-generated software is held to the same standards expected of a human engineering team.

Unlike single-purpose prompt libraries or one-off "coding agent" wrappers, Superpowers is explicitly a methodology plus a skills library, not a single tool. It is agent-agnostic by design: the same skill set installs into 13+ different coding agents (Claude Code, Cursor, Gemini CLI, GitHub Copilot CLI, Devin, and more), rather than being tied to one vendor's ecosystem. It also favors "systematic over ad-hoc" decision-making and "evidence over claims," distinguishing it from lighter-weight prompt-engineering collections that don't enforce process discipline.

3. Feature Categories

🧪 Testing — 1 skill. test-driven-development enforces a strict RED-GREEN-REFACTOR loop so agents write a failing test before writing implementation code.
🐞 Debugging — 2 skills. systematic-debugging drives root-cause analysis instead of guesswork; verification-before-completion blocks an agent from marking work "done" without actual evidence it works.
🤝 Collaboration — 9 skills. Includes brainstorming (design validation with the user before coding), writing-plans / executing-plans (task decomposition and execution), dispatching-parallel-agents (fan-out work to subagents), requesting-code-review / receiving-code-review, using-git-worktrees (isolated, safe development branches), finishing-a-development-branch, and subagent-driven-development.
🧩 Meta — 2 skills. writing-skills documents how to author new skills; using-superpowers explains how the framework itself should be invoked and composed.

4. Key Highlights

Seven-stage development workflow — every task moves through design brainstorming, git worktree isolation, task decomposition, subagent execution with review cycles, TDD, spec-based code review, and branch cleanup, giving agent-driven development a consistent shape.
Agent-agnostic installation — works across 13+ coding agents (Claude Code, Cursor, Codex CLI, Gemini CLI, GitHub Copilot CLI, Devin, Antigravity, Factory Droid, Grok Build CLI, Kimi Code, OpenCode, Pi, Hermes Agent), so teams aren't locked into a single vendor.
Test-driven development by default — the test-driven-development skill makes RED-GREEN-REFACTOR the default loop rather than an optional discipline.
Evidence-over-claims verification — verification-before-completion is designed specifically to stop agents from self-reporting success without proof.
Git worktree isolation — development happens in isolated worktrees, keeping experimental or in-progress agent work from destabilizing the main branch.
Composable, extensible skills library — skills are modular Markdown-based units (SKILL.md), and writing-skills documents the pattern for teams who want to add their own.

5. Use Cases by Role

General developers — install Superpowers into your coding agent of choice to get structured planning, TDD enforcement, and code review baked into everyday agent-assisted coding sessions.
Project managers / tech leads — use the brainstorming and planning skills to get agents to surface design trade-offs and produce reviewable plans before implementation starts, reducing surprise rewrites.
Open-source maintainers — the using-git-worktrees and finishing-a-development-branch skills help keep agent-submitted branches isolated and clean, easing review burden on maintainers.

(DevOps/SRE, security engineering, and data/research science are not distinct focus areas of this project and are omitted.)

6. Getting Started

Find what you need
Browse the skills library by category (testing, debugging, collaboration, meta) in the skills/ directory of the repository, or read docs/ for agent-specific setup notes.

Install / integrate
Installation is a single command specific to your coding agent, for example:

# Claude Code
/plugin install superpowers@claude-plugins-official

# Cursor
/add-plugin superpowers

# Gemini CLI
gemini extensions install https://github.com/obra/superpowers

# GitHub Copilot CLI
copilot plugin install superpowers@superpowers-marketplace

See the repository README for the full table covering all 13+ supported agents.

Contribute
Fork the repository, work from the dev branch, and follow the methodology documented in skills/writing-skills/SKILL.md before opening a pull request. Note that maintainers state they generally do not accept contributions of entirely new skills — bug fixes and improvements to existing skills are the primary contribution path.

7. Project Structure

superpowers/
├── .claude-plugin/     # Claude Code plugin manifest
├── .cursor-plugin/     # Cursor plugin manifest
├── .devin-plugin/      # Devin plugin manifest
├── .kimi-plugin/       # Kimi Code plugin manifest
├── .opencode/          # OpenCode extension + INSTALL.md
├── .pi/extensions/     # Pi extension manifest
├── .agents/plugins/    # Shared agent plugin definitions
├── skills/             # Core skills library (SKILL.md per skill)
├── docs/               # Agent-specific and general documentation
├── hooks/              # Workflow hooks
├── scripts/            # Supporting automation scripts
├── assets/             # Static assets (logo, telemetry pixel, etc.)
└── tests/              # Test suite / eval harness

The skills/ directory is the heart of the project — each skill is a self-contained SKILL.md describing when and how an agent should apply it. The .{agent}-plugin/ directories adapt the same skill library to each supported coding agent's plugin format.

8. Related Ecosystem

Superpowers depends on the coding-agent platforms it installs into — Claude Code, Cursor, Gemini CLI, GitHub Copilot CLI, Codex CLI, Devin, Antigravity, Factory Droid, Grok Build CLI, Kimi Code, OpenCode, Pi, and Hermes Agent — each providing the underlying LLM runtime and plugin/extension mechanism that Superpowers' skills run on top of. It complements (rather than replaces) each agent's native capabilities by layering a shared development methodology on top of them.

9. License

✅ Free to use, copy, modify, merge, publish, and distribute, including for commercial purposes (MIT License).
✅ Free to install into any supported coding agent, personal or organizational.
❌ No warranty is provided — the software is offered "as is."
ℹ️ The original copyright and license notice must be retained in copies or substantial portions of the software.
ℹ️ The project includes optional, opt-out telemetry (version-adoption tracking via a logo-load beacon); it can be disabled via an environment variable.

10. FAQ

Q: Does Superpowers work with my coding agent?
A: It supports 13+ agents including Claude Code, Cursor, Gemini CLI, GitHub Copilot CLI, Codex CLI, and Devin — check the installation table in the README for the exact command for your agent.

Q: Is Superpowers a single tool or a set of prompts?
A: Neither exactly — it's a structured methodology implemented as a composable skills library (skills/), designed to be invoked by an agent throughout a full development workflow rather than a one-shot prompt.

Q: Can I contribute a new skill?
A: You can open a pull request, but maintainers note they generally don't accept contributions of entirely new skills; contributions that improve existing skills, docs, or agent integrations are more likely to be merged. See skills/writing-skills/SKILL.md for the required format.

Q: Does it collect my data?
A: It includes optional telemetry limited to version-adoption tracking, which respects an opt-out environment variable.

Q: How do I update Superpowers after installing it?
A: Updating follows your coding agent's normal plugin/extension update mechanism; see the "Updating" section of the repository README for details specific to your agent.

11. Quick Links

Repository: https://github.com/obra/superpowers
Contributing guide: skills/writing-skills/SKILL.md (in the repository)
Agent-specific docs: docs/ directory (in the repository)
Community: GitHub Issues and Discussions on the repository

12. Summary

Superpowers turns ad-hoc AI-assisted coding into a disciplined, evidence-based engineering process — brainstorming, planning, TDD, and code review — that installs into whichever coding agent a team already uses. It's most valuable for developers and teams who want their AI coding agents to behave like careful engineers rather than fast-but-sloppy autocomplete, without being locked into a single agent vendor.