The editorial argues that superpowers' explosive growth reveals a quiet shift in the agentic-coding narrative: for two years the assumption was that bigger context windows and better tool use would unlock quality, but what's actually unlocking it is procedural discipline imposed on the agent. The 113k stars are evidence that engineers have found a methodology layer matters more right now than raw model gains.
Vincent deliberately ships no model, no runtime, and no new harness — just plain markdown skills that force Claude Code to behave like a careful senior engineer (TDD before implementation, reproduce before theorize, restate before coding). The deflationary tagline 'a methodology that works' signals his position that the win comes from constraining the agent, not from new infrastructure.
The editorial emphasizes that superpowers reached 113k stars with no VC launch, no staged HN push, and no influencer coordination — a near-vertical trending curve driven entirely by engineers who tried it and shipped faster. That organic trajectory, compared against repos like Zed and Bun, is treated as independent validation that the methodology genuinely works in practice.
In the last few weeks, `obra/superpowers` — a GitHub repo from Jesse Vincent (Keyboardio co-founder, longtime Perl hacker, now very public Claude Code power user) — crossed 113,500 stars. The tagline is deliberately deflationary: *"An agentic skills framework & software development methodology that works."* No model. No runtime. No new agent harness. What Vincent shipped is essentially a disciplined operating manual for Claude Code — a set of skills, prompts, and workflow files that force an AI agent to work the way a careful senior engineer would.
The structure is unglamorous on purpose. Skills are plain markdown. There's a TDD skill that refuses to let the agent write implementation before a failing test. A debugging skill that insists on reproducing before theorizing. A code-review skill that walks a diff file-by-file with explicit stop-and-think gates. A "brainstorm" skill that forbids writing code at all until the problem is restated. Taken together, it's less a framework than a procedural straitjacket — one that an agent voluntarily puts on because the top-level instruction tells it to.
For a repo that is, mechanically, a pile of instruction files, 113k stars is a lot. For context, that's more than Zed, more than Bun's early breakout, within arm's reach of Next.js territory. The growth curve on GitHub Trending has been near-vertical for weeks, with no VC launch, no HN front-page staged push, and no influencer coordinated drop. It got there by word of mouth from engineers who tried it and shipped faster.
For two years the agentic-coding story has been about capabilities: bigger context windows, better tool use, more autonomous loops, longer-horizon tasks. The implicit assumption was that if you kept scaling the model and the harness, the quality of the output would follow. That assumption is quietly dying.
What superpowers makes legible is that the ceiling on agentic coding, right now, is not model capability — it's methodology. A Sonnet-class model with a tight TDD skill in place out-produces the same model running unconstrained, because the unconstrained version writes 400 lines of plausible-looking code that doesn't quite work, and the constrained version writes 40 lines that do. The skills don't make the model smarter. They make it less stupid in a specific, repeatable way.
This is the same lesson the software industry already learned once, in meatspace, between roughly 1995 and 2010. XP, Scrum, TDD, pair programming, code review, continuous integration — none of those made individual engineers smarter either. They constrained the ways engineers were allowed to be dumb. Superpowers is, almost literally, that body of practice ported to agents. Vincent is not shy about this: the skills read like someone translated *Kent Beck's Test-Driven Development: By Example* into imperative mood and handed it to a very fast, slightly reckless junior.
The community reaction tells you where this lands. On HN and in the usual Twitter clusters, two camps have formed. One camp — mostly senior engineers who ship a lot — treats superpowers like finding glasses they didn't know they needed: *"this is just how I was already trying to use the agent, written down."* The other camp — mostly people whose relationship to AI coding is more theoretical — reads it as a step backward, a return to prescriptive methodology after years of "just prompt it." Both camps are correct, which is why the stargazer graph looks the way it does.
The deeper point, and the one most takes are missing: this is a bet that the valuable artifact in the AI-coding stack is not the model, not the harness, and not the IDE — it's the procedural knowledge of how to actually make software. That knowledge has historically been locked inside senior engineers' heads and leaked out slowly through books, blog posts, and the hard lesson of watching a bad PR get reverted. Superpowers is the first widely-adopted attempt to serialize it into a form a machine can execute. If it works — and 113k stars is pretty strong evidence it works for enough people to matter — then the next competitive edge in AI-assisted development is going to be whoever writes the best skills, not whoever ships the best model.
There's also a quieter implication for tool vendors. Cursor, Windsurf, Zed's agent mode, Copilot Workspace — they've been competing on UX, context handling, and model routing. None of them ship opinionated methodology. Superpowers suggests the market gap is exactly there: an IDE that doesn't just run an agent but *trains the agent* on your team's preferred procedure. The first vendor to ship "bring your own superpowers" as a first-class feature probably wins a surprising amount of share.
If you're using Claude Code (or any agentic coding tool) in a serious way, the practical takeaway is immediate: install it, or steal from it. The skills are MIT-licensed markdown. You can clone them, read them, and keep the ones that match your team's taste. The TDD and debugging skills in particular are worth stealing wholesale — they capture practices that most teams enforce via social pressure in code review, which is a terrible place to enforce them.
Second, treat your `CLAUDE.md` (or equivalent) as a real artifact. Most teams' agent instruction files are a dumping ground of "don't do X" rules written reactively after the agent did X. Superpowers' structure — small, named, invokable skills with clear entry conditions — is a strictly better pattern. Refactor accordingly. The investment pays back on the first non-trivial task where the agent would otherwise have gone sideways.
Third, if you're building developer tools: the methodology layer is now a product surface. Shipping a coding agent without a skills library in 2026 is going to feel like shipping a build tool without a plugin ecosystem in 2015. The ones who treat it as core infrastructure, not a prompt-engineering afterthought, will have the moat.
The interesting question isn't whether superpowers itself keeps growing — stars are a lagging indicator and the real test is whether teams are still using it in six months. The interesting question is what gets built on top. Expect forks that encode specific stacks (a Rails superpowers, a Go superpowers), expect commercial skill libraries from consultancies who want to productize their playbooks, and expect the next wave of agent tooling to ship with skills as a first-class concept rather than as a bolted-on markdown convention. The methodology layer is here. It just arrived on GitHub, 113k stars at a time, written in markdown by someone who used to make keyboards.
An agentic skills framework & software development methodology that works.
→ read on GitHubTop 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.