Superpowers: The Complete Guide to the Agentic Skills Framework That Actually Works
What if your AI coding agent didn't just write code — but followed a complete software development methodology? Superpowers is an agentic skills framework and software development methodology by Jesse Vincent (obra) that transforms your coding agent from a code generator into a disciplined engineering partner. It starts with brainstorming your design, creates isolated git worktrees, breaks work into 2-5 minute tasks, dispatches subagents with two-stage code review, enforces strict RED-GREEN-REFACTOR TDD, and finishes with clean merge workflows.
With 72,500+ GitHub stars, 5,500+ forks, 19 contributors, and support for Claude Code, Cursor, Codex, and OpenCode, Superpowers has become one of the most popular agentic development frameworks — not because it adds more features, but because it enforces a methodology that actually produces reliable software.
What Is Superpowers?
Superpowers is a complete software development workflow for coding agents, built on composable "skills" and initial instructions that ensure your agent uses them. The key insight: skills trigger automatically — you don't need to invoke them manually. Your coding agent just has Superpowers.
Here's what happens when you start building something:
- The agent doesn't jump into code. Instead, it steps back and asks what you're really trying to do
- It teases a specification out of the conversation, presenting it in chunks short enough to actually read and digest
- After you sign off on the design, it creates an implementation plan clear enough for "an enthusiastic junior engineer with poor taste, no judgement, no project context, and an aversion to testing"
- It emphasizes TDD, YAGNI, and DRY throughout the process
- Once you say "go", it launches subagent-driven development — having agents work through each task, inspecting and reviewing their work
It's not uncommon for Claude to work autonomously for a couple hours at a time without deviating from the plan you put together. That's the power of methodology over ad-hoc prompting.
The Basic Workflow
Superpowers defines a 7-step workflow, with each step triggered by a specific skill:
Step 1: Brainstorming
Skill: brainstorming
- Activates before writing any code
- Refines rough ideas through Socratic questioning
- Explores alternatives you might not have considered
- Presents design in sections for validation
- Saves the design document
Step 2: Git Worktrees
Skill: using-git-worktrees
- Activates after design approval
- Creates an isolated workspace on a new branch
- Runs project setup
- Verifies a clean test baseline
Step 3: Writing Plans
Skill: writing-plans
- Activates with an approved design
- Breaks work into bite-sized tasks (2-5 minutes each)
- Every task has exact file paths, complete code expectations, and verification steps
Step 4: Subagent-Driven Development
Skill: subagent-driven-development or executing-plans
- Activates with a plan
- Subagent mode: Dispatches a fresh subagent per task with two-stage review:
- Spec compliance check
- Code quality review
- Batch mode: Executes in batches with human checkpoints
Step 5: Test-Driven Development
Skill: test-driven-development
- Activates during implementation
- Enforces strict RED-GREEN-REFACTOR:
- Write a failing test
- Watch it fail
- Write minimal code to make it pass
- Watch it pass
- Commit
- Deletes code written before tests — this isn't a suggestion, it's enforced
Step 6: Code Review
Skill: requesting-code-review
- Activates between tasks
- Reviews against the plan
- Reports issues by severity
- Critical issues block progress
Step 7: Finishing
Skill: finishing-a-development-branch
- Activates when all tasks are complete
- Verifies all tests pass
- Presents options: merge, PR, keep, or discard
- Cleans up the worktree
The agent checks for relevant skills before any task. These are mandatory workflows, not suggestions.
Skills Library
Superpowers includes 15 skills organized into four categories:
Testing
| Skill | Description |
|---|---|
| test-driven-development | RED-GREEN-REFACTOR cycle with testing anti-patterns reference |
Debugging
| Skill | Description |
|---|---|
| systematic-debugging | 4-phase root cause process with root-cause-tracing, defense-in-depth, and condition-based-waiting techniques |
| verification-before-completion | Ensures a fix is actually fixed before declaring success |
Collaboration
| Skill | Description |
|---|---|
| brainstorming | Socratic design refinement |
| writing-plans | Detailed implementation plans |
| executing-plans | Batch execution with human checkpoints |
| dispatching-parallel-agents | Concurrent subagent workflows |
| requesting-code-review | Pre-review checklist |
| receiving-code-review | Responding to code review feedback |
| using-git-worktrees | Parallel development branches |
| finishing-a-development-branch | Merge/PR decision workflow |
| subagent-driven-development | Fast iteration with two-stage review (spec compliance, then code quality) |
Meta
| Skill | Description |
|---|---|
| writing-skills | Create new skills following best practices (includes testing methodology) |
| using-superpowers | Introduction to the skills system |
Installation
Claude Code (Plugin Marketplace)
# Register the marketplace
/plugin marketplace add obra/superpowers-marketplace
# Install the plugin
/plugin install superpowers@superpowers-marketplace
Cursor
/plugin-add superpowers
Codex
Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.codex/INSTALL.md
OpenCode
Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.opencode/INSTALL.md
Verify Installation
Start a new session and ask for something that should trigger a skill (e.g., "help me plan this feature" or "let's debug this issue"). The agent should automatically invoke the relevant skill.
Updating
/plugin update superpowers
Philosophy
Superpowers is built on four core engineering principles:
-
Test-Driven Development — Write tests first, always. The framework will actually delete code you write before tests. This is non-negotiable.
-
Systematic over Ad-Hoc — Process beats guessing. Every debugging session follows a 4-phase root cause process. Every implementation follows a plan.
-
Complexity Reduction — Simplicity is the primary goal. YAGNI (You Aren't Gonna Need It) is enforced throughout. Tasks are broken into 2-5 minute chunks.
-
Evidence over Claims — Verify before declaring success. The
verification-before-completionskill ensures fixes are actually fixed.
Read more on the philosophy: Superpowers for Claude Code
Superpowers vs Alternatives
Each agentic development framework has genuine strengths:
| Feature | Superpowers | Everything Claude Code | Anthropic Skills | Antigravity Awesome Skills | Custom CLAUDE.md |
|---|---|---|---|---|---|
| Development Methodology | ✅ Full 7-step workflow | Partial (skills only) | ❌ (skill format only) | ❌ (catalog only) | Per-project |
| TDD Enforcement | ✅ Strict RED-GREEN-REFACTOR | ✅ TDD skill | ❌ | ❌ | Manual |
| Subagent Orchestration | ✅ Two-stage review | ✅ Multi-agent commands | ❌ | ❌ | ❌ |
| Git Worktree Management | ✅ Built-in | ❌ | ❌ | ❌ | ❌ |
| Brainstorming/Design | ✅ Socratic method | ✅ Planner agent | ❌ | ❌ | ❌ |
| Skills Count | 15 focused | 60+ integrated | 17 official | 1,200+ aggregated | Custom |
| Hook Automations | ❌ | ✅ Full system | ❌ | ❌ | ❌ |
| Security Scanning | ❌ | ✅ AgentShield | ❌ | ❌ | ❌ |
| Continuous Learning | ❌ | ✅ Instincts | ❌ | ❌ | ❌ |
| Platform Support | 4 tools | 4 tools | 16+ tools | 6+ tools | Claude Code |
| Official Standard | ❌ | Community | ✅ agentskills.io | Community | ❌ |
| Community | 72K ⭐ | 62K ⭐ | 85K+ ⭐ (Anthropic) | Growing | Individual |
| Ease of Setup | ✅ Plugin install | Plugin install | ✅ Plugin install | Copy skills | ✅ Simple |
When to choose Superpowers: You want a complete, opinionated software development methodology — not just skills, but an enforced workflow that ensures your agent follows TDD, uses git worktrees, plans before coding, and reviews its own work. Ideal for developers who value process discipline.
When to choose Everything Claude Code: You need a broader toolkit with hook automations, security scanning (AgentShield), code quality enforcement (Plankton), and continuous learning — more features, less methodology enforcement.
When to choose Anthropic Skills: You want the official, industry-standard format adopted by 16+ tools, or you need production document skills (docx/pdf/pptx/xlsx).
When to choose Antigravity Awesome Skills: You want the largest catalog of skills (1,200+) from multiple providers across 6+ tools.
When to choose Custom CLAUDE.md: You want quick, lightweight, per-project instructions without a full framework.
FAQ
What is Superpowers?
An agentic skills framework and software development methodology. It gives your coding agent a complete workflow: brainstorm → plan → implement with TDD → review → merge.
Who created it?
Jesse Vincent (obra) — a well-known open-source developer. The project is MIT licensed.
Which platforms does it support?
Claude Code, Cursor, Codex, and OpenCode — all via plugin marketplaces or install scripts.
Does it enforce TDD?
Yes, strictly. The test-driven-development skill enforces RED-GREEN-REFACTOR and will delete code written before tests. This is a mandatory workflow, not a suggestion.
What's subagent-driven development?
Superpowers dispatches a fresh subagent for each engineering task, with a two-stage review process: first checking spec compliance, then code quality. This allows hours of autonomous work without deviation.
How many skills does it include?
15 skills across Testing, Debugging, Collaboration, and Meta categories. Quality over quantity — each skill is deeply integrated into the overall workflow.
Can I create my own skills?
Yes. The writing-skills skill teaches you how to create new skills following best practices, including a testing methodology.
Is it free?
Yes — MIT licensed. Jesse Vincent encourages sponsors via GitHub Sponsors for those who benefit commercially.
Conclusion
Superpowers has earned its 72,500+ stars by answering a question most skills frameworks ignore: how should an AI agent actually build software? While other tools focus on adding more skills or features, Superpowers focuses on methodology — a complete, enforced workflow from brainstorming through merge that produces reliable, tested, well-reviewed code.
The strict TDD enforcement, subagent-driven development with two-stage review, git worktree isolation, and systematic debugging process create a framework where your AI agent doesn't just write code — it engineers software. That's the difference between having an AI tool and having an AI engineering partner.