Superpowers Claude Skill Review 2026: The #1 Skills Framework Tested

Table of Contents

1. What is the Superpowers Skill?
2. Key Features
3. How to Install Superpowers
4. Pricing
5. Pros and Cons
6. Alternatives
7. Final Verdict: Is Superpowers Worth It?
8. Submit Your Own Review
9. Frequently Asked Questions
10. Related Articles

What is the Superpowers Skill?

Superpowers is an open-source agentic skills framework and software development methodology for Claude Code. It was created by Jesse Vincent — known as obra on GitHub — a veteran open-source developer whose resume includes building Request Tracker (RT) in the 1990s, managing Perl 6 from 2005 to 2008, co-founding Keyboardio, and building K-9 Mail for Android (later acquired by Mozilla and rebranded as Thunderbird for Android).

Vincent published his first blog post about the methodology in October 2025 on blog.fsck.com, describing how he had evolved an effective process for working with coding agents. The core insight was simple but powerful: AI coding agents are not lacking in intelligence — they are lacking in discipline. Left to their own devices, they skip tests, ignore architecture, and attempt ad-hoc fixes instead of systematic debugging.

Superpowers fixes this by encoding proven software engineering workflows into composable "skills" — structured instruction files that Claude reads and follows automatically. When a skill applies to your current task, it activates. There is no opt-in. If you are implementing a feature, the TDD skill kicks in. If you are debugging, the systematic debugging methodology activates. If you are starting a new project, the brainstorming skill fires before any code is written.

We installed Superpowers and tested it on five different projects over two weeks: a Next.js SaaS dashboard, a Go REST API, a React Native mobile app, a Python data pipeline, and a Chrome extension. The results were consistent across all five. Claude went from producing functional but unstructured code to delivering work that looked like it came from a senior developer following a company's engineering playbook.

On January 15, 2026, Superpowers was accepted into the official Anthropic Claude Code plugin marketplace — a milestone that signals both quality and institutional trust. As of March 2026, the GitHub repository has accumulated over 42,000 stars with 3,100+ forks, making it the most-starred Claude skill project by a significant margin.

The project is MIT-licensed, entirely free, and actively maintained by Vincent and the community through Prime Radiant, his company. Version 2.0 split the monolithic plugin into a lightweight shim that manages a local clone of the superpowers-skills repository, making community contributions seamless.

The obra/superpowers repository — 42K+ stars and the most forked Claude skill on GitHub

Key Features

1. Socratic Brainstorming

This is where Superpowers earns the "senior developer" comparison. When you tell Claude to build something, it does not start writing code. It starts asking questions.

The brainstorming skill activates automatically before implementation begins. Claude runs what feels like a requirements workshop — asking what you are really trying to accomplish, surfacing edge cases you had not considered, exploring alternative approaches, and clarifying constraints. The conversation is Socratic: Claude presents observations and asks targeted questions rather than making assumptions.

We tested this on our Next.js dashboard project. We said "add a real-time notification system." Without Superpowers, Claude immediately started writing a WebSocket implementation. With Superpowers, it first asked about notification types, persistence requirements, user preference controls, mobile considerations, and rate limiting — then presented three architectural options with trade-offs before writing a single line. The final implementation was meaningfully better because the requirements were actually understood first.

2. Micro-Task Planning with Write-Plan

After brainstorming, the /superpowers:write-plan command breaks your project into bite-sized tasks — each designed to take two to five minutes to complete. This is not a vague roadmap. Each task has specific acceptance criteria, clear dependencies, and a defined scope.

The planning skill writes the plan to a markdown file in your project directory. This is critical. Instead of Claude burning through its context window trying to hold the entire project in memory, the plan persists on disk. You never lose context between sessions. If Claude's context resets, it reads the plan file and picks up exactly where it left off.

On our Go REST API project, Superpowers broke a "build user authentication" request into 14 micro-tasks: from defining the User struct, to writing table migration SQL, to implementing each endpoint, to adding rate limiting. Each task was small enough to review and verify independently. No scope drift. No forgotten edge cases.

3. Test-Driven Development Enforcement

This is the feature that generates the most conversation — and the most resistance from developers who are not used to strict TDD.

Superpowers enforces a red-green-refactor cycle on every implementation task. Claude writes the test first. The test must fail (red). Then Claude writes the minimum code to make the test pass (green). Then it refactors. This cycle repeats for every micro-task in the plan.

The enforcement is not optional. If a skill applies to your task, you must use it. Superpowers' core philosophy is that skipping crucial steps on "simple" tasks is how bugs enter production. Our test coverage across all five projects consistently landed between 85% and 95% — enterprise-grade numbers that we would never have achieved with vanilla Claude Code.

4. Systematic Debugging Methodology

When something breaks, most AI agents try random fixes until something works. Superpowers replaces this chaos with a four-phase methodology: reproduce, investigate root cause, formulate a hypothesis, and only then implement a fix.

The debugging skill activates automatically when Claude encounters an error or when you report a bug. It prevents the agent from touching any code until it can articulate what is actually wrong and why. On our Python data pipeline, a race condition in concurrent processing would have taken vanilla Claude down a rabbit hole of random mutex additions. With Superpowers, Claude first reproduced the issue, traced the execution flow, identified the specific shared state causing the race, and then applied a targeted fix with a regression test.

5. Subagent-Driven Development with Code Review

Superpowers does not just have Claude do all the work in a single thread. It delegates implementation tasks to subagents — separate Claude instances that each handle one micro-task from the plan. After each subagent completes its work, a dedicated code-reviewer agent evaluates the implementation against the plan, coding standards, and architectural principles.

Critical issues block the merge. The reviewer is not polite about it. If a subagent produced code that violates the plan or introduces a security concern, the review skill flags it and the work goes back for revision before moving forward. This catches issues that would otherwise compound across tasks.

On our Chrome extension project, the review agent caught three instances where a subagent had introduced direct DOM manipulation instead of using the message-passing architecture defined in the plan. Without the review step, those inconsistencies would have created maintenance headaches weeks later.

6. Verification Before Completion

Superpowers includes a verification skill that activates before Claude claims work is done. It runs the full test suite, checks for uncommitted changes, verifies the implementation matches the plan, and confirms no tasks were skipped or partially completed.

This sounds simple, but it eliminates one of the most frustrating patterns in AI-assisted coding: Claude confidently announcing "Done!" when the code does not actually compile, tests are failing, or half the requirements are missing. With Superpowers, "done" means verified done.

7. Skills Authoring and Extension

Superpowers is not just a fixed set of skills — it includes a meta-skill for writing new skills. If your team has specific workflows, coding standards, or review processes, you can encode them as custom skills that integrate into the Superpowers pipeline.

The community has taken full advantage of this. The superpowers-skills repository contains community-contributed skills, and the superpowers-lab repo serves as an experimental testing ground for new techniques. The skill format is documented, the contribution process is straightforward, and the MIT license means no restrictions on custom modifications.

8. Context Persistence via Markdown Files

Every phase of the Superpowers workflow — brainstorming notes, plans, progress, review feedback — is written to markdown files in your project directory. This is a deliberate architectural choice. Markdown files are human-readable, version-controllable, and survive across sessions.

If Claude's context window fills up, it does not lose the project state. It reads the plan file. If you switch to a different machine, the plan comes with the repository. If you want to review what Claude was thinking during the brainstorming phase, you read a file. No opaque databases, no proprietary formats. Just markdown that Git tracks alongside your code.

How to Install Superpowers

There are three ways to get Superpowers running on your machine. All three take under two minutes.

Method 1: Claude Code Plugin Marketplace (Recommended)

Since January 2026, Superpowers is available through the official Anthropic plugin marketplace. This is the simplest installation path.

# Register the marketplace
/plugin marketplace add obra/superpowers-marketplace

# Install Superpowers
/plugin install superpowers@superpowers-marketplace

Skills activate automatically after installation. No configuration required.

Method 2: Direct GitHub Clone

If you prefer manual control, clone the repository directly into your project's .claude/skills/ directory:

git clone https://github.com/obra/superpowers.git .claude/skills/superpowers

This gives you full access to the source, the ability to pin specific versions, and the option to fork and customize.

Method 3: One-Click Install via Skiln.co

Browse to the Superpowers page on Skiln, click the install button, and follow the guided setup. Skiln handles version management and provides a visual interface for enabling or disabling individual skills within the framework.

Pricing

Superpowers is completely free and open source under the MIT license.

There are no paid tiers, no premium features, no usage limits, and no telemetry. The entire framework — core skills, community skills, experimental lab — is available to everyone.

The only cost associated with Superpowers is indirect: the additional Claude API tokens consumed by the brainstorming, planning, and review phases. Because Superpowers makes Claude do more work per task (asking questions, writing plans, running reviews), your token usage will increase compared to vanilla Claude Code. In our testing, the increase was roughly 30-40% per task — but the reduction in rework and debugging more than offset the additional token spend.

Pros and Cons

Pros

• Dramatically better code quality — Test coverage consistently hits 85-95% across projects, with architectural consistency enforced by the review phase
• Eliminates the "just start coding" problem — The brainstorming and planning phases catch requirements gaps before they become expensive bugs
• Works across all languages and frameworks — We tested on TypeScript, Go, Python, and browser extensions with equally strong results
• Persistent context — Markdown-based plans survive session resets, machine switches, and context window limits
• Actively maintained — Jesse Vincent and the community ship regular updates; the plugin marketplace integration ensures compatibility with the latest Claude Code
• Cross-agent compatible — Skills work on Claude Code, OpenAI Codex CLI, Gemini CLI, Cursor, and GitHub Copilot without modification
• No vendor lock-in — MIT license, no accounts, no API keys, no telemetry

Cons

• Upfront time cost — The brainstorming and planning phases add 10-20 minutes before any code is written, which feels heavy for small fixes
• Rigid by design — You cannot skip phases. If the TDD skill applies, you are writing tests first whether you want to or not. This is intentional but frustrating for quick prototypes
• Higher token consumption — Expect 30-40% more API token usage per task due to the additional brainstorming, planning, and review phases
• Overkill for trivial tasks — Fixing a typo or updating a dependency version does not need a brainstorming session, but Superpowers may still activate planning steps
• Learning curve for non-TDD developers — If your team does not practice test-driven development, the strict red-green-refactor enforcement will feel foreign initially
• Community skills vary in quality — The core skills are excellent, but community-contributed skills in superpowers-skills range from polished to experimental

Alternatives

Superpowers occupies a unique position as a full-lifecycle development framework. Most alternatives focus on one aspect of the development process rather than the entire workflow. Here is how the top contenders compare.

Frontend Design (Anthropic)

The official Anthropic frontend design skill is the highest-installed skill in the ecosystem (277,000+ installs as of March 2026). It gives Claude a design system and aesthetic philosophy before it touches any UI code — forcing bold color choices, distinctive typography, and intentional animations instead of defaulting to generic Tailwind templates. It is not a competitor to Superpowers; it is complementary. Install both. Frontend Design handles how things look, Superpowers handles how they are built.

Playwright Pro (Anthropic)

Another official Anthropic skill, Playwright Pro ships with 55+ test templates, flaky test diagnostics, and live browser automation. Where Superpowers enforces TDD methodology, Playwright Pro provides the actual testing infrastructure for browser-based applications. Again, complementary rather than competing. Superpowers tells Claude to write tests first; Playwright Pro gives it the tools to write better browser tests.

Trail of Bits Security

Built by the security firm that audits major protocols, this skill adds CodeQL and Semgrep-based static analysis to Claude's workflow. It focuses exclusively on security — finding vulnerabilities, enforcing secure patterns, and flagging risky code. Superpowers' code review catches architectural issues; Trail of Bits catches security issues. For production applications, both are worth installing.

Custom CLAUDE.md Instructions

The lowest-tech alternative is writing your own CLAUDE.md file with development instructions. This works for simple constraints ("always use TypeScript strict mode," "run tests before committing") but cannot replicate Superpowers' multi-phase orchestration, subagent delegation, or automatic skill activation. Think of it as the difference between a checklist and a full engineering playbook.

Final Verdict: Is Superpowers Worth It?

Yes. Unequivocally.

We went into this review skeptical. A skill that "makes Claude Code 100x better" sounded like hype. After two weeks and five projects, our conclusion is more measured but firmly positive: Superpowers does not make Claude 100x better. It makes Claude consistently good.

Without Superpowers, Claude Code produces work that ranges from brilliant to sloppy depending on the task, the context window state, and sheer luck. With Superpowers, the floor rises dramatically. The worst output you get is still structured, tested, and reviewed. The brainstorming phase alone prevented at least three significant architectural mistakes across our test projects.

The rigid workflow will frustrate developers who want fast, ad-hoc code generation. That is the point. Superpowers is opinionated. It believes that skipping planning and tests is never worth the time saved. If you disagree with that philosophy, this is not the skill for you.

For everyone else — especially teams working on production applications, developers building anything beyond prototypes, and anyone tired of Claude confidently producing untested code — Superpowers is the first skill you should install. It is free, it is open source, and it works.

Final Rating: 4.8/5

We deducted 0.2 points for the upfront time cost on small tasks and the occasionally overzealous activation on trivial changes. Everything else is best-in-class.

Browse Superpowers on Skiln →

Submit Your Own Review

Frequently Asked Questions

What is the Superpowers Claude skill?

Superpowers is an open-source skills framework for Claude Code created by Jesse Vincent (obra). It transforms Claude from a reactive code generator into a structured senior engineering partner by enforcing Socratic brainstorming, micro-task planning, test-driven development, and continuous code review on every project.

Is Superpowers free to use?

Yes. Superpowers is completely free and open source under the MIT license. There are no paid tiers, premium features, or usage limits. The only indirect cost is the additional Claude API tokens consumed by the brainstorming, planning, and review phases — roughly 30-40% more per task.

How do I install Superpowers on Claude Code?

The easiest method is through the official plugin marketplace. Run /plugin marketplace add obra/superpowers-marketplace followed by /plugin install superpowers@superpowers-marketplace in Claude Code. Alternatively, clone the GitHub repository directly into your project's .claude/skills/ directory.

Does Superpowers work with other AI coding tools besides Claude Code?

Yes. Superpowers skills follow the open Agent Skills specification, which means they work across Claude Code, OpenAI Codex CLI, Gemini CLI, Cursor, and GitHub Copilot without modification. You install once and use everywhere.

Will Superpowers slow down my workflow?

The brainstorming and planning phases add 10-20 minutes of upfront time before coding begins. For trivial tasks like typo fixes, this feels excessive. For anything beyond a quick change — new features, refactors, bug investigations — the upfront investment reduces total time by catching issues early and eliminating rework cycles.

Can I disable specific Superpowers skills?

Yes. While Superpowers is opinionated about activating skills when they are relevant, you can disable individual skills by removing their SKILL.md files from the skills directory. However, the framework is designed as a cohesive workflow — disabling the TDD skill while keeping the planning skill undermines the methodology.

Who created Superpowers?

Superpowers was created by Jesse Vincent, known as obra on GitHub. Vincent is a veteran open-source developer who previously built Request Tracker, managed Perl 6, co-founded Keyboardio, and created K-9 Mail for Android (now Thunderbird for Android). He develops Superpowers through Prime Radiant, his company.

How does Superpowers compare to writing my own CLAUDE.md instructions?

A custom CLAUDE.md file works for simple constraints like enforcing TypeScript strict mode or requiring tests before commits. Superpowers goes far beyond this with multi-phase orchestration, subagent delegation, automatic skill activation based on task type, persistent markdown-based planning, and a code review pipeline. It is the difference between a checklist and a full engineering playbook.

Related Articles

• What Are Claude Skills? A Complete Guide — Everything you need to know about the skills ecosystem
• 15 Best Claude Skills for Developers in 2026 — Our ranked list of the top skills, including Superpowers at #1
• How to Install Claude Skills (3 Methods) — Step-by-step installation guide for any skill