265,000 Stars and I Don't Use Any of It

A friend sent me a link this morning: obra/superpowers. Jesse Vincent's agentic skills framework for Claude Code.

265,503 stars. I pulled that from the API rather than trusting the badge, because I assumed I was misreading it. I wasn't. Twenty-three thousand forks. Created in October 2025. It is, by star count, one of the most popular repositories on GitHub.

I have never used it. I have never used any of them. I run a heavily customised setup of my own design, and my justification has always been the same one sentence: I know exactly what mine does.

That's a comfortable position. It's also the kind of position that quietly rots if you never test it. So I spent the morning actually reading the ecosystem — the source, not the marketing — and this is what's in there, what they've all independently agreed on, and what I'm stealing without installing anything.

First, the Scale of This Thing

Star counts are a vanity metric. They are also the only comparable number available across projects with wildly different distribution channels. Pulled live from the GitHub API on 3 August 2026:

Two things stand out. Superpowers has more than twice the stars of GitHub's own spec-kit. And awesome-claude-code, sitting at 51k, is a list of links — it out-stars most of the actual software. Discovery is apparently a harder problem than methodology.

What Superpowers Actually Is

Mechanically it is unglamorous, and that's the point. It's Markdown. A skill is a directory containing an instruction file plus any scripts it references. There is no runtime, no model wrapper, no clever inference.

It installs through Anthropic's own plugin marketplace:

/plugin install superpowers@claude-plugins-official

# or from the project's own marketplace
/plugin marketplace add obra/superpowers-marketplace

What you get is a library of skills that trigger on context rather than on request — the agent is instructed to check whether a skill applies before doing anything, load it, and follow it. The README is blunt about the intent: "Mandatory workflows, not suggestions."

The enforced sequence:

The stated philosophy is four lines: test-driven development, systematic over ad-hoc, complexity reduction, evidence over claims. The pitch is that agents can work autonomously for a couple of hours without drifting off the plan.

These Are Not All the Same Thing

The single most useful thing to come out of the morning was realising that "Claude Code framework" is a label covering at least seven different categories of software, which people compare as though they were competitors. A prompt library cannot give you process isolation. An orchestration runtime does not produce good specifications. A GUI that launches six agents is not a multi-agent strategy — it's six terminals with better ergonomics.

The other four worth knowing

What They All Independently Agreed On

This is the section that changed my mind about the exercise being worthwhile.

Where these projects differ is mostly taste. Where they converged is evidence. These are separate teams, separate philosophies, separate audiences — arriving at the same primitives:

That list is not one framework's opinion. It's the shape of the problem showing through. Agentic coding has developed recognisable engineering primitives, and it took about eighteen months.

The Honest Case Against Me

Let me steelman the thing I don't do, because "I know what mine does" can very easily become a flattering story.

And the Case For Doing It Myself

Now the other side — and here there are actual numbers, not just preference.

One caveat I'll hold myself to: the strongest custom setup is not a pile of personal prompts. It's a small, inspectable framework built for one environment, with explicit interfaces and its own tests. If mine isn't that, the argument doesn't apply to me.

What I'm Stealing Without Installing Anything

This is the actual output of the morning. Nine techniques, each portable into a custom setup, none requiring you to adopt the surrounding mythology.

Where This Goes

Anthropic shipping official Skills, Plugins and a marketplace absorbs the packaging layer. Discovery, installation, namespacing, updates, hooks, distribution — those are natural vendor features, and Superpowers already installs through the official marketplace. MCP does the same for tool exposure: "our framework can call a database" stops being an advantage once every client speaks the protocol.

Parallel sessions, worktrees, background execution, diff views and resumability will drift down into the products too. Launching several agents will stop being distinctive.

What survives is the layer containing judgment. A methodology that encodes how your company designs migrations or reviews security-sensitive changes. A context system that understands your ownership and build structure. An orchestration policy that knows which tasks are safely parallel in your architecture.

The investment rule falls out of that: don't build proprietary machinery for commodity installation, generic protocols or terminal multiplexing. Invest in inspectable workflow definitions, domain-specific gates, evaluation, durable project memory, and verification that produces evidence.

So — Do I Install It?

No. And I'm more comfortable with that than I was this morning, for a better reason than I had this morning.

The reason isn't that these projects are bad. Superpowers is genuinely good, and its core diagnosis — that process, not model capability, is what's failing you — is right. 265,000 people did not star a Markdown repository by accident.

The reason is that the value in these frameworks is the ideas, and ideas are free. The packaging costs context, opacity and version churn. The nine techniques in the table above are the entire payload. I can implement every one of them in my own system, in my own vocabulary, tuned to my own repositories, and still be able to explain what every instruction in my stack is doing and why.

But the position only holds under one condition, and it's worth stating plainly because it's the part that's easy to skip:

I've been running my own setup for long enough that I'd stopped reading anyone else's. That was the actual mistake — not the building. One link from a friend was worth a morning, and I came out with nine things to implement and a much sharper account of why I'm not installing the thing that gave them to me.