Development Methodology
131K+ Starsby Jesse Vincent (obra)An agentic skills framework and software development methodology that works.
Superpowers is not just another Claude Code extension — it is a complete development methodology delivered as automatically-activating skills. With 131K+ GitHub stars, it is the most popular project in the entire Claude Code ecosystem. Install it once, and every Claude Code session becomes spec-first, TDD-enforced, and subagent-verified by default.
Created by Jesse Vincent, a veteran open-source developer, Superpowers embodies a specific philosophy: the quality ceiling of AI-assisted development depends more on process discipline than model capability. A well-structured methodology with automatic enforcement produces consistently better results than a more powerful model with no guardrails.
Spec-First Design
TDD Enforcement
Subagent Inspection
Cross-Platform
Core Methodology
Claude Code asks clarifying questions before writing any code. The agent produces a specification broken into digestible chunks for developer approval. Only after explicit confirmation does implementation begin. This prevents the most common AI coding failure: building the wrong thing fast.
Key Benefits
Every feature follows true red/green test-driven development. Failing tests are written first, then minimum implementation code is written to pass them, then refactoring happens with tests as a safety net. YAGNI and DRY principles are enforced automatically.
Key Benefits
Superpowers launches independent subagents for code review, testing, type checking, and documentation. Each subagent inspects the work from its specialized perspective. This enables hours of autonomous high-quality development because every change is independently verified.
Key Benefits
Superpowers works with Claude Code, Cursor, Codex, and OpenCode. The same methodology skills apply regardless of which tool you use. Skills activate automatically on install — zero configuration needed.
Key Benefits
Ecosystem
Superpowers is more than a single project. The ecosystem includes companion repositories for skills, marketplace distribution, experimental research, and browser integration.
superpowers
FoundationCore framework — methodology skills and subagent system
131K+ stars
superpowers-skills
ExtensionsCommunity skill packs for specialized workflows
594 stars
superpowers-marketplace
DistributionSkill discovery and distribution platform
781 stars
superpowers-lab
ResearchExperimental features and methodology research
265 stars
superpowers-chrome
IntegrationBrowser integration for web-based Claude workflows
231 stars
Comparison
Three projects, three philosophies. Superpowers enforces methodology. oh-my-claudecode orchestrates teams. Best Practice documents the patterns. Most serious Claude Code users combine elements from all three.
| Dimension | Superpowers | oh-my-claudecode | Best Practice |
|---|---|---|---|
| Core approach | Methodology enforcement | Team pipeline orchestration | Knowledge documentation |
| Primary mechanism | Auto-activating skills | Staged agent pipeline | Paired docs (practice + implementation) |
| TDD support | Enforced (red/green) | Through team-verify stage | Documented patterns |
| Spec/requirements | Spec-first questioning | Deep Interview + team-prd | Best practice guides |
| Platform support | Claude Code, Cursor, Codex, OpenCode | Claude Code, Codex | Universal (docs) |
| GitHub stars | 131K+ | 21K+ | 30K+ |
| Best for | Solo dev quality ceiling | Multi-agent team simulation | Learning patterns & principles |
Getting Started
1. Install from Marketplace
Search for “Superpowers” in the Claude Code marketplace or clone the GitHub repository directly. Installation takes under a minute.
2. Start a New Session
Skills activate automatically. Ask Claude Code to build a feature and notice the difference: it will ask clarifying questions and produce a spec before writing any code.
3. Review the Spec
Superpowers breaks the specification into digestible chunks. Review each chunk, ask questions, request changes. Only approve when the spec matches your intent.
4. Watch TDD in Action
After spec approval, Claude Code writes failing tests first, then implements minimum code to pass them, then refactors. Subagents review the work independently.
Execution Brief
Use this page as a rollout checklist, not just reference text.
Tool Mapping Lens
Catalog-oriented pages work best when users can map discovery, evaluation, and rollout in a clear path instead of reading an undifferentiated list.
Use this board for Superpowers Framework before rollout. Capture inputs, apply one decision rule, execute the checklist, and log outcome.
Input: Objective
Deliver one measurable improvement with superpowers claude code framework
Input: Baseline Window
20-30 minutes
Input: Fallback Window
8-12 minutes
| Decision Trigger | Action | Expected Output |
|---|---|---|
| Input: one workflow objective and release owner are defined | Run preview execution with fixed acceptance criteria. | Go or hold decision backed by repeatable evidence. |
| Input: output quality below baseline or retries increase | Limit scope, isolate root issue, and rerun controlled test. | One confirmed correction path before wider rollout. |
| Input: checks pass for two consecutive replay windows | Promote to broader traffic with fallback path active. | Stable rollout with low operational surprise. |
tool=superpowers claude code framework objective= preview_result=pass|fail primary_metric= next_step=rollout|patch|hold
Superpowers is the most popular skills framework in the Claude Code ecosystem, with over 131,000 GitHub stars. Created by Jesse Vincent (obra), it delivers a complete software development methodology through automatically-activating skills that change how Claude Code behaves from the first message of every session.
The framework is built on four pillars: spec-first design that prevents building the wrong thing, TDD enforcement that guarantees test coverage, subagent inspection that provides automatic multi-perspective code review, and cross-platform support that works with Claude Code, Cursor, Codex, and OpenCode.
What makes Superpowers unique is its philosophy: the quality ceiling of AI-assisted development depends on process discipline, not model capability. A structured methodology with automatic enforcement consistently outperforms a more powerful model running without guardrails. Superpowers embeds this principle in every interaction.
The project has spawned an ecosystem of companion repositories: superpowers-skills for community skill packs, superpowers-marketplace for distribution, superpowers-lab for experiments, and superpowers-chrome for browser integration. Together, they form the most comprehensive development methodology platform for AI-assisted coding.
Install Superpowers from the Claude Code marketplace with a single command. There is no configuration step — skills activate automatically. Your very next Claude Code session will follow the spec-first, TDD-enforced, subagent-verified methodology.
Start with a medium-complexity feature to experience the workflow. Notice that Claude Code asks clarifying questions before writing code, produces a specification for your review, writes tests before implementation, and launches subagents for verification. This is the Superpowers workflow in action.
Trust the process for the first few sessions even if it feels slower initially. The spec and TDD phases add upfront time but dramatically reduce rework, debugging, and misunderstanding. Most developers report net time savings within their first week of using Superpowers on real projects.
Extend the framework by installing community skill packs from superpowers-skills or building your own. Custom skills can enforce domain-specific practices — security review for auth code, performance testing for data pipelines, accessibility checks for UI components — that complement the core methodology.
Treat this page as a decision map. Build a shortlist fast, then run a focused second pass for security, ownership, and operational fit.
When a team keeps one shared selection rubric, tool adoption speeds up because evaluators stop debating criteria every time a new option appears.
Outcome: A production-ready payment integration with comprehensive test coverage, proper security review, and verified Stripe best practices — built correctly the first time because the spec caught missing requirements before any code was written.
Outcome: A security-critical refactor completed with automatic multi-perspective review, catching issues that a single-pass review would have missed.
Outcome: A production-quality feature from a junior developer, with the Superpowers methodology serving as an automatic mentor that teaches professional practices through guided enforcement rather than lectures.
Superpowers is an agentic skills framework and software development methodology created by Jesse Vincent (obra). With over 131,000 GitHub stars, it is the most popular Claude Code enhancement project. Superpowers changes how Claude Code behaves from the first message — enforcing spec-first design, TDD, subagent delegation, and automatic review throughout every session.
When Superpowers is active, Claude Code does not start writing code immediately. Instead, it asks clarifying questions about the task, produces a specification broken into digestible chunks for approval, and only begins implementation after the developer confirms the spec. This prevents the common failure mode of building the wrong thing because the requirements were not properly understood.
Superpowers enforces true red/green test-driven development. For every feature, the agent writes failing tests first (red), implements the minimum code to pass them (green), and refactors once tests are green. The framework also enforces YAGNI (You Aren't Gonna Need It) and DRY (Don't Repeat Yourself) principles, preventing over-engineering during the implementation phase.
Superpowers launches subagents for specific engineering tasks — code review, testing, type checking, documentation — with automatic inspection and review. Each subagent operates independently with minimal context, and results are synthesized in the parent session. This enables hours of autonomous, high-quality development work because every change is independently verified.
Yes. Superpowers is cross-platform and works with Claude Code (via the official marketplace), Cursor, Codex, and OpenCode. The same methodology skills apply regardless of which AI coding tool you use. The framework adapts its activation and interaction patterns to match each platform's capabilities.
Beyond the core framework, the ecosystem includes superpowers-skills (594 stars) for community skill packs, superpowers-marketplace (781 stars) for skill discovery and distribution, superpowers-lab (265 stars) for experimental features, and superpowers-chrome (231 stars) for browser integration. Together, these projects create a comprehensive development methodology platform.
Install from the Claude Code marketplace with a single command, or clone the GitHub repository directly. Superpowers skills activate automatically — there is no configuration required. Once installed, Claude Code's behavior changes immediately: it will ask clarifying questions before coding, write tests before implementation, and launch subagents for review and verification.
Superpowers is excellent for beginners because it enforces professional development practices automatically. A beginner using Superpowers will naturally follow spec-first, TDD, and code review workflows without needing to understand the underlying methodology. The framework acts as a built-in mentor that guides the development process toward best practices.
Send the exact workflow you are solving and we will prioritize a new comparison or rollout guide.