What is Obra Superpowers?

Superpowers is a Claude Code methodology framework built by Jesse 'Obra' Vincent (formerly at Anthropic). It bundles 14+ skills covering brainstorming, planning, TDD, subagent review, verification before completion, and writing skills themselves. Distributed via the official anthropics/claude-plugins-official marketplace and via Obra's repository at github.com/obra/superpowers. 120k+ stars as of May 2026.

Is Superpowers worth installing if I already have my own workflow?

Maybe. Superpowers is opinionated — it imposes a brainstorm → plan → implement → verify loop on most non-trivial work. Teams that already have discipline get less marginal value. Teams that ship via 'vibe coding' get a lot. The dissent on Hacker News is roughly 60/40 in favor; the 40% complaint is 'over-engineering for small tasks'.

Does Superpowers work in Cursor or Codex CLI?

Partially. The skills' YAML frontmatter is Claude-specific, but the methodology content in each SKILL.md body is mostly tool-agnostic. Some teams port them to Cursor rules or Codex CLI prompts; the trigger semantics differ. Obra's official focus is Claude Code.

What's the 'verification before completion' skill?

A skill that auto-triggers when Claude is about to claim work is complete. It requires Claude to (a) name the verification command, (b) run it, (c) paste the output, (d) only then claim done. Catches the 'I think this works' anti-pattern that produces broken builds. We treat it as one of the highest-ROI skills in the entire pack.

Obra Superpowers Explained: What It Actually Does

Jesse "Obra" Vincent worked at Anthropic. He left, kept building inside Claude Code, and in September-October 2025 released Superpowers — a methodology framework distributed as a Claude Code plugin. The plugin bundles 14+ skills that, taken together, push Claude Code into a disciplined engineering workflow instead of free-form generation.

As of May 2026, Superpowers has 120k+ stars on GitHub, is distributed through the official anthropics/claude-plugins-official marketplace, and has spawned a small ecosystem of community forks and skill extensions. Hacker News reviews are roughly 60/40 in favor — the praise centers on "shifts vibe coding into agentic engineering"; the criticism centers on "over-engineering for small tasks."

This page explains what Superpowers actually does, when to install it, and how it composes with other patterns in the Claude Code ecosystem.

The core skills

Superpowers ships 14+ skills. The ones that do most of the work:

1. brainstorming. Auto-triggers before any creative work — features, components, behavior changes. The skill blocks immediate implementation and forces a discussion of user intent, requirements, and design first. The exact prompt: "You MUST use this before any creative work." Heavy hand, deliberately. 2. writing-plans. Triggers when there's a spec or set of requirements and the work is multi-step. The skill produces a written implementation plan with phases, success criteria, and reviewer checkpoints before any code is written. 3. executing-plans. Triggers when there's an existing plan to execute. Walks through phases sequentially with review gates between them. Designed to be paired with writing-plans. 4. test-driven-development. Enforces RED-GREEN-REFACTOR. When Claude is asked to implement a feature, this skill redirects to "write the failing test first" — even when the user didn't ask for tests. The opinionated answer is: tests aren't optional. 5. systematic-debugging. Triggers on any bug report, test failure, or unexpected behavior. The skill blocks the "try this fix" pattern and forces hypothesis formation before any code changes. Specifically: name the hypothesis, name the evidence that would prove or disprove it, gather the evidence, then act. 6. verification-before-completion. Triggers when Claude is about to claim work is done. Requires running verification commands and confirming output before any "complete," "fixed," or "passing" claim. The single highest-ROI skill in the pack — catches the "I think this works" anti-pattern across the entire session. 7. subagent-driven-development. Triggers when 2+ independent tasks are visible. The skill dispatches parallel subagents for the independent pieces with full briefs (file paths, quality bar, validation command, return format). See /topic/subagents for the underlying primitive. 8. requesting-code-review. Triggers when major features are implemented or before merging. Spawns a subagent with a code-review brief and waits for the result before claiming the work is mergeable. 9. receiving-code-review. The mirror of #8. When code review feedback arrives, this skill blocks the "agree and implement everything" pattern. Each review point gets explicit technical evaluation — agree, disagree with reason, or escalate. 10. writing-skills. Recursive: the skill that helps you write more skills. Used when creating, editing, or verifying skill descriptions. Particularly enforces the trigger-phrase discipline covered in /topic/skill-description-engineering. 11. finishing-a-development-branch. Triggers when implementation is complete and you need to decide how to integrate — merge, PR, or cleanup. Structured options instead of "what now?" 12. using-git-worktrees. Triggers when starting feature work that needs isolation. Sets up a git worktree (or falls back to a branch) so the agent's experimental changes don't trash the main workspace. 13. dispatching-parallel-agents. Same primitive as subagent-driven-development but explicit — used when you have 2+ tasks that share no state and want to fan out aggressively. 14. using-superpowers. Meta-skill that auto-triggers at the start of any conversation. Establishes how to find and use other skills, requires explicit invocation of the Skill tool before any response.

What Superpowers gets right

Three patterns that show up repeatedly across the skills and that we think are correct.

Forcing planning before code. The brainstorming and writing-plans skills are deliberately heavy-handed. They block. They make it slower to start coding. That is the feature — for non-trivial work, the planning time is recovered 3-10x in the time you don't waste on the wrong implementation. The vibe-coding default is to start typing; Superpowers' default is to think first. Subagent-driven review. Inline self-review by Claude is post-hoc rationalization — the model defends the choices it just made. Subagent review with fresh context catches real issues. Superpowers makes this the default for any non-trivial change, which is the right default. Verification before completion. Most "I'm done" claims from Claude are wrong. The verification skill forces a command + output + only-then-claim pattern. We've adopted this pattern outside of Superpowers entirely — it's the highest-ROI engineering discipline we've seen in Claude Code. TDD discipline. Claude is biased toward writing implementation before tests because the implementation feels like progress. TDD inverts the bias: a failing test is the only progress that counts. RED-GREEN-REFACTOR is hard to drift from when the skill is enforcing it.

What Superpowers gets wrong (or where the dissent lives)

The 40% Hacker News dissent isn't wrong either. Three patterns where Superpowers' opinionated defaults are wrong for some workflows:

Brainstorming on tiny tasks. "Rename this variable" doesn't need a brainstorming session. The brainstorming skill is heavy and slow; for changes that fit in a single mental model the overhead is pure cost. Anthropic's official skills are lighter-weight; Superpowers is opinionated about wanting heaviness everywhere. The skill-discovery overhead. With 14 always-loaded skills the description budget gets thick. /doctor will show you the listing budget; on smaller setups Superpowers can crowd out other skills. Anti-haste bias. Some workflows need to ship fast — exploratory prototypes, throwaway demos, internal tooling. Superpowers' planning-first defaults are wrong for these. Disable the brainstorming and writing-plans skills if you're prototyping, or don't install Superpowers for that project. Cross-tool drift. Superpowers is Claude-Code-specific. If your team uses Cursor, Codex CLI, or other agents alongside Claude, you'll need to maintain parallel patterns or accept that Superpowers' value is bounded to one tool.

How to install

Two paths:

Via the official marketplace:

/plugin install superpowers@claude-plugins-official

That's it. Skills load on next session start.

Via direct git clone:

cd ~/.claude/plugins
git clone https://github.com/obra/superpowers.git

Pin to a specific commit if you want stability — the active development cadence means HEAD can ship breaking changes to skill descriptions.

When to install vs when to skip

A simple decision tree:

Situation	Superpowers?
Building non-trivial features in production code	Yes
Prototyping or throwaway work	No — too heavy
Solo developer, small project	Try it for two weeks, keep what works
Team workflow with established conventions	Cherry-pick skills (verification-before-completion, subagent-driven-development) rather than installing the full pack
Want a fast on-ramp to disciplined Claude Code use	Yes — it's the fastest existing path
Already deep into your own methodology	Skip; read the skill bodies for ideas

The community fork obra/superpowers-skills exists as an alternative distribution with the same content but different packaging — usable if you want the skills without the plugin manifest.

Superpowers vs autoresearch vs Spec Kit

The SERPs conflate these. They are different categories.

Superpowers. Methodology framework. Brainstorm → plan → implement → verify. Built around subagent orchestration and verification discipline. Use when you want to impose engineering rigor on Claude Code. Autoresearch. Autonomous iteration loop. Define a metric and a constraint; let the model optimize. Use when you have a measurable target and want overnight grinding. See /topic/autoresearch. Spec Kit (GitHub). Spec-first toolkit. Specify → plan → tasks → implement. Use when the spec is the authoritative artifact and code generation flows from it.

You can use all three. Superpowers structures a feature; autoresearch optimizes a parameter inside the feature; Spec Kit owns the document. We've never installed all three in one project, but the boundaries are clear enough that you could.

Where this fits in the bigger pattern

The deeper claim Superpowers makes — embedded in every skill — is that engineering discipline beats model capability for production work. The model is good. The model is not good enough to consistently produce production-grade output without process. The process is what Superpowers encodes.

This is the same claim as Hamel Husain's evals work, as Shreya Shankar's "tool-agnostic processes" framing, and as the broader "agentic engineering" wave that Karpathy named at Sequoia 2026. The toolset varies; the underlying claim is consistent.

If you're approaching Claude Code as "magic that produces code," Superpowers will feel heavy. If you're approaching it as "a capable agent that needs scaffolding to produce production work," Superpowers feels right.

Where this fails

The pack is large. 14+ skills, each loading its description into context every session. On modest Claude Code setups the listing budget gets crowded. Run /doctor after install to confirm you have headroom. Update cadence is fast. Obra ships changes frequently. Pin to a commit or accept that your workflow might shift week-to-week. Some skills overlap. subagent-driven-development and dispatching-parallel-agents cover similar territory. We rarely use both; one or the other depending on the work. Not all skills are equally valuable. From our usage, the top five (verification-before-completion, subagent-driven-development, test-driven-development, brainstorming, writing-plans) are 80% of the value. The rest are situational. You can cherry-pick if you want.

Sources

Obra (Jesse Vincent). superpowers repository. 120k+ stars.
Obra. superpowers-skills (community fork). Same content, different packaging.
Obra. "Why your Claude skill isn't triggering". Author context.
Anthropic. claude-plugins-official repository. Where Superpowers ships through the official channel.
HN 47623101. "Superpowers rave review". Community reception.
HN 45547344. "Show HN: Superpowers (original post)".
Hamel Husain. "Evals FAQ". Adjacent thesis on process over tools.
Shreya Shankar. On tool-agnostic evals. "Better to learn the processes."
Karpathy. Sequoia AI Ascent 2026. "Vibe coding raised the floor; agentic engineering raises the ceiling." Superpowers is one of the named examples.