Superpowers review: the AI coding-agent repo that's blowing up right now, 243k stars

A month or two ago, I was surveying the Claude Code ecosystem, looking at which plugins and skills were worth installing, when I came across a repo called superpowers by obra. Its GitHub star count stopped me: over two hundred forty thousand, in under a year. Its one-line description reads "an agentic skills framework and software development methodology that works."

I installed it, tried it, and then read the actual source inside. I expected to find some clever trick. What I found was more striking than a trick. The core idea of a repo with a quarter of a million stars was the same one I had just written into my own skill, without ever having seen this repo.

So this post is two things at once. First, what superpowers is and why it is worth trying. Second, the core idea worth taking even if you never install it, ending with the point where it matched something I had already built. Because when two unrelated people arrive at the same answer without planning to, that answer tends to be a real principle, not just a matter of taste.

Part 1What Superpowers is, and why the star count

Superpowers is an open-source repo with around fourteen skills for AI coding agents. Its premise is that most AI, given a task, jumps straight into writing code, and that habit is what breaks the work. Superpowers forces it to work in the order an engineer would: brainstorm the design first, write a plan, break work into small pieces, write a test before the code, and verify against real output before claiming done.

The skills include brainstorming (dig into the problem before acting), writing-plans (break work into pieces of a few minutes each), test-driven-development (make the test fail first, then make it pass), systematic-debugging (find the root cause in steps), and verification-before-completion (do not say done until you have run it and seen the result). None of this is new to the field. What is different is that it actually makes the AI follow through.

Why the star count is interesting

Two hundred forty thousand stars in under a year is a signal that a lot of people hit the same problem: AI keeps getting better at writing code, yet still works in a rush, skips steps, and reports done before verifying. Superpowers sells exactly that fix. The other clever part is that one skill set reaches many hosts: Claude Code, Cursor, Codex. The skills live in one place, so editing one file takes effect everywhere, with no copying between tools.

Part 2The idea worth taking: name the excuse inside the rule

If I had to take one idea from superpowers, it would not be the steps. Those you can read anywhere. The rarer thing is how it makes the AI actually follow them, because the problem was never that the AI does not know it should write a test. The problem is that it can always find a reason to skip.

Superpowers solves this in a strikingly blunt way: inside each skill, it writes down the excuses an agent uses to skip that step, right in the instruction, paired with the counterargument. A real example from its own files: the test-first skill has a line that reads, roughly, "thinking of skipping TDD just this once? Stop. That is rationalization," and a table of excuses and rebuttals, such as "too simple to test" paired with "simple code breaks, the test takes thirty seconds."

The skill that opens every session is even clearer. It says, in capital letters, that if there is even a one percent chance a skill applies, you must invoke it, followed by a line that all but dares the agent: "this is not negotiable, and you cannot rationalize your way out of this." It reads as heavy-handed, but it is heavy-handed on purpose, because it knows the AI will look for a way around.

A guardrail the AI can talk its way past is not a guardrail. Writing the rule down is not enough. You have to name the excuse it will use to skip the rule, inside the rule.

The other half of why it works is timing. Superpowers does not wait for the agent to remember these skills exist. It injects the skill set into the session at the start (SessionStart) and flags it as extremely important. The result is that working systematically becomes the default, not an option you hope the agent chooses. A guardrail that only works if someone remembers it tends to fail exactly when you need it most.

Part 3Where it matched something I had already built

This is the part that actually stopped me. Before finding superpowers, I had just written a skill to fix a specific problem of my own: in certain moments an AI will quietly fabricate a tool's output, such as inventing a commit hash or a link before it has run the real command, and then build on that fake value. It is a dangerous kind of error because it is hard to spot.

What I wrote into that skill was not just "do not fabricate results." I went through the excuses the AI itself would use to do it, and wrote a rule to preempt each one. For instance: a broad "do all of it" command does not mean you should guess the result of every step at once; or, the phrase "forwarding to the client for execution" is the end of the turn, not a result, so do not invent what the result will be.

Then I opened superpowers and saw its excuse-and-rebuttal table in every skill, and I realized the two of us had walked to the same method: neither of us trusted a rule stated plainly to bind the AI. You have to preempt the excuse for it to bind at all. Built separately, no copying, same answer.

That matters more than it looks. When two unrelated sources arrive at the same answer without coordinating, what you have found is usually not one person's taste but a principle that comes from the nature of the problem itself. Here the nature is that AI tends to find reasons to skip a rule. So a good guardrail has to preempt the excuse, not just announce the rule.

Part 4Should you install it, and how to use the idea yourself

Should you install Superpowers?

If you write real code with AI, it is worth trying. The risk is low: inside it is plain Markdown and YAML, with no hidden machinery running in the background. The skills are simply read into the agent's context. My advice is to install it, try it, and see which steps fit the rhythm of your work. You do not need to enable every skill from day one. I took some of it, not the whole set.

If you want a way to decide before you commit to any plugin or skill, I wrote a framework for evaluating Claude Code plugins before you install them. The same test applies cleanly to superpowers.

The idea you can use right now, even without the repo

When you write a rule for an AI, whether it is a skill, an instruction file, or a long prompt, add this step: write the excuse the AI will use to skip the rule right into the rule, with the reason that excuse is false. The shift in thinking is this: do not only ask what you want it to do. Ask what it will claim in order not to do it, and preempt that first.

The machinery that makes the whole set run together as a system, injecting skills at session start, sequencing which step comes after which, and how I wire it into my own skill, is something I am building as a separate tool and will not detail here. But the principle above you can use immediately, without waiting for any of that.

The one rule to remember

If you remember one thing from this post, let it be this: a guardrail the AI can talk its way past is not a guardrail. A good rule does not end at declaring what is forbidden. It lives in preempting the excuse the AI will use to skip it, inside the rule itself. A repo with a quarter of a million stars understands this, and I arrived at it on my own, from real work.

This post is one layer in the 7-layer architecture of a production AI agent.