Claude Superpowers: The Skills Collection, Explained

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.

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 4.8, Sonnet 4.6, 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, 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 claude 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

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 claude 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 claude superpowers 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 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 claude superpowers 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

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 claude superpowers 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

Here is the part that matters most, and the reason "trust the source" is not boilerplate. Claude Code skills — including every one in claude superpowers — 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 claude 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

You do not have to choose. Many developers run the claude 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.

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.