Claude Superpowers: The Skills Collection, Explained

Claude superpowers is a popular open-source collection of Claude Code skills — the community project by Jesse Vincent (obra) — that bundles dozens of ready-made workflows so Claude Code plans, debugs, tests, and reviews code in a disciplined way. It is unofficial, not built by Anthropic, and runs on your machine.

Skill mechanics and plugin install routes verified 31 July 2026 against the Claude Code skills documentation.

If you have used Claude Code for a while, you have probably felt the gap between "it writes code" and "it works the way a careful senior engineer works." That gap is exactly what the claude superpowers project tries to close. Instead of one clever prompt, it gives Claude Code a whole library of composable skills plus the glue that makes Claude actually reach for them at the right moment. Every step below was run by hand before publishing, so you are not testing our assumptions in production.

This guide explains what the superpowers skills collection is, why people install it, how it is set up, and — importantly — how to vet it before you let third-party code run on your computer. The skills work with the Claude models Claude Code currently runs on — the latest lineup includes Opus 5, Sonnet 5, and Haiku 4.5 — and this guide is reviewed regularly, so the steps below should take under 10 minutes to follow and stay accurate as the project evolves.

What "claude superpowers" actually is

Superpowers is a community-maintained, MIT-licensed pack of Claude Code skills from the obra/superpowers repository. Each skill is a SKILL.md folder teaching Claude one job, and an orchestration skill nudges Claude to reach for the right one.

Superpowers is a community-maintained, open-source project (the main repository is obra/superpowers on GitHub). Its author describes it as "a complete software development methodology for your coding agents, built on top of a set of composable skills" plus some initial instructions that make sure the agent actually uses them.

In plain terms: it is a big pack of Claude Code skills. A skill is a small, self-contained folder — a SKILL.md file with instructions, and sometimes helper scripts — that teaches Claude how to do one job well. On its own, Claude Code supports skills natively; the Superpowers collection simply ships a curated, battle-tested set of them so you do not have to write each one from scratch.

Two things make it stand out. First, breadth: it covers a real end-to-end development loop, not a single trick. Second, orchestration: it includes a "using-superpowers" skill and setup instructions that nudge Claude to consult the right skill automatically, so the workflow feels cohesive rather than a pile of disconnected snippets.

It is worth saying clearly and up front: claude superpowers is not an Anthropic product. It is a third-party project, released under an open-source (MIT) license, by an independent developer and community. That is a strength — it moves fast and reflects real practitioner habits — but it also means the usual "trust the source" caution applies.

Why people use the superpowers skills collection

They encode engineering discipline as reusable procedure: brainstorm before building, keep planning and execution as separate steps, write failing tests first, drive debugging from root cause, and close a two-way review loop before calling work done.

The appeal of the superpowers skills is that they encode good engineering discipline as reusable procedure. Left to a plain prompt, an AI agent tends to jump straight to code. The Superpowers workflow instead pushes a sequence closer to how experienced teams operate:

• Brainstorm before building. A design-exploration step surfaces options and trade-offs before a single line is written.
• Write a plan, then execute it. Planning and execution are separate skills, which keeps Claude from wandering mid-task rather than jumping straight to code.
• Test-driven development. A red-green-refactor skill makes Claude write failing tests first, then code to pass them.
• Systematic debugging. Instead of guessing, a debugging skill drives root-cause analysis and verification.
• Code review, both directions. Skills for requesting and receiving review add a self-checking loop before work is called "done."

People adopt it because it turns "please be careful" into concrete, repeatable steps. You are not hoping the model remembers best practices — the skills bake them in.

What kinds of skills are inside

The roster is organised by development lifecycle rather than by feature: testing, debugging, planning, collaboration and review, plus meta skills for authoring your own. The exact list shifts as contributors add skills, so treat the categories as durable.

The collection is organized around the software-development lifecycle rather than one feature. Broadly, the superpowers skills fall into a few buckets. The exact roster changes as the community adds and refines skills, so treat the categories — not any fixed count — as the durable picture.

The testing and debugging skills push a methodical loop — failing test first, then implementation, then a verification pass. The planning and collaboration skills handle brainstorming, writing and executing plans, managing parallel work with git worktrees, and running code review. There are also meta skills, including one for writing your own skills, which pairs naturally with learning how to build a Claude skill yourself.

That overlap is deliberate. Many people install the pack first to see disciplined agent behavior in action, then start authoring their own skills using the same patterns. If you want a broader survey of what is out there beyond this one project, our roundup of the best Claude skills is a good next stop.

How claude superpowers is installed

It ships as a Claude Code plugin, installed either from a plugin marketplace or directly from the GitHub repository. Reload Claude Code afterwards and check the skill listing. Take the exact commands from the project README, not from any blog.

Superpowers is delivered as a Claude Code plugin, so it rides on Claude Code's plugin and marketplace system. At a high level there are two routes, and you should always take the exact, current commands from the project's official README rather than a blog (this one included):

1. Via a plugin marketplace. You add the project's marketplace to Claude Code, then install the superpowers plugin from it. The README lists the precise /plugin install superpowers@… command and which marketplace to point at. Because the project also appears in the official plugin marketplace, the exact source name can change over time — check the README.
2. Directly from the GitHub repo. For a more manual setup, you can install straight from the repository. The general pattern is the same idea behind installing Claude skills from GitHub: you point Claude Code at the repo so its skills land in your Claude skills directory.

Whichever route you pick, restart or reload Claude Code afterward, then confirm the skills are visible. A quick /help or the skill/plugin listing command will show whether the plugin registered. Once it is active, Claude will begin reaching for the skills on relevant tasks — and the project also exposes slash commands (for example, a brainstorm or write-plan command) so you can invoke steps explicitly.

Because the install specifics evolve — marketplace names, command syntax, supported hosts — I am deliberately not hard-coding them here. The README is the source of truth. Copy from it, not from memory.

The security caveat you should not skip

Skills can run scripts on your machine with your permissions. Install only from the canonical repository or the official marketplace listing, read the SKILL.md files and helper scripts before trusting them, and re-skim anything that changes on update.

Here is the part that matters most, and the reason "trust the source" is not boilerplate. Claude Code skills — including every one in this collection — can include scripts that run on your machine with your permissions. That is what makes them powerful, and it is also what makes them a real supply-chain consideration.

Before installing the superpowers skills, apply the same care you would to any third-party dependency:

• Install only from the official source. Use the canonical obra/superpowers repository or the official marketplace listing. Typosquats and forks of popular projects are a known risk — a lookalike name is a red flag.
• Read what it does. Skim the SKILL.md files and any helper scripts. You are looking for what commands they run, what they read or write, and whether anything reaches out to the network.
• Trust the source. A well-known, active, open-source project with public history and many contributors is easier to trust than an anonymous repo with three stars. Provenance is signal.
• Keep an eye on updates. Skills change. When you update, you are pulling new code — re-skim anything that changed, especially scripts.

None of this is unique to Superpowers; it applies to any skill collection. But because superpowers is popular and broad, it is worth being deliberate. If you would not curl | bash a random script, do not blindly install a skill pack either. The good news is that the project is open, widely used, and auditable — which is exactly what makes it reasonable to trust once you have looked.

Superpowers versus building your own skills

It is not a choice between the two. Most developers run the pack as a baseline and layer their own skills on top for house conventions, deployment checklists, and domain review rubrics — the collection even includes a skill about writing skills.

You do not have to choose. Many developers run the Superpowers collection as a strong baseline and layer their own custom skills on top for project-specific needs — a house code style, a deployment checklist, a domain-specific review rubric. The superpowers project even includes a skill about writing skills, so it doubles as a teaching tool.

Running this site out of Claude Code, the discipline from this collection that earned its place for us was plan-before-code. Letting an agent jump straight to edits produced the diffs we later spent the most time unwinding; making it write a short plan first turned that cleanup into a quick review of the plan instead. We do not run the full obra pack day to day — we lifted the two or three ideas that mattered into our own house skills — but watching them work here is what convinced us they were worth encoding.

If your goal is understanding the mechanism rather than adopting one big pack, start by learning how skills work in Claude Code and then walk through authoring your first one. The superpowers skills are a fast way to see the ceiling of what is possible; your own skills are how you tailor that to your actual codebase.