# Superpowers Agentic Skills Framework: 298K Stars [2026]

> obra/superpowers went from a one-point Hacker News post to ~298,000 GitHub stars and an official Anthropic plugin. Here's how the agentic skills framework works, what v7.0.0 changed, and which productivity claims actually hold up.

- Canonical: https://www.kunalganglani.com/blog/superpowers-agentic-skills-framework
- Author: Kunal Ganglani
- Published: 2026-10-12 · Updated: 2026-10-12
- Category: Technology · Tags: claude-code, ai-coding-agents, agentic-ai, developer-tools, open-source

## TL;DR

Superpowers is a free set of rules that makes AI coding assistants work like a disciplined engineer instead of an eager intern. Instead of letting the AI jump straight to writing code, it forces a sequence: talk through the idea, write a plan, write the tests first, then build, and have a second AI check the work. One developer, Jesse Vincent, released it in late 2025, and it exploded to nearly 300,000 GitHub stars and an official Anthropic listing within a year. The catch: its impressive speed and quality numbers come mostly from the people who built it, not independent studies. It's genuinely useful, just not magic.

## Superpowers Framework [2026]: 298K Stars, Claims Tested

Superpowers is a free, open-source agentic skills framework that forces AI coding agents to follow a disciplined brainstorm → spec → plan → test-driven development → subagent-review workflow instead of improvising their way to a diff. Created by Jesse Vincent in October 2025, it climbed from a Hacker News post that nobody upvoted to 298,135 GitHub stars by October 2026, plus an official listing in Anthropic's plugin marketplace. It exists to fix the loudest complaint about coding agents: drift.

![black flat screen computer monitor](https://cdn.sanity.io/images/vzekdneq/production/a49b797ab205ab8fa9a462f799facde2ba9b30e9-1200x675.webp)

If you've read any of the other explainers on this topic, you're reading stale numbers. The most-updated competitor piece still cites ~226,000 stars and v5.1.0 from mid-June. As of October 12, 2026, the repo has 298,135 stars and 26,643 forks. I pulled those straight from the GitHub API rather than a secondhand citation. And version 7.0.0 shipped two days earlier, on October 10, a release that rebuilt the brainstorming skill from scratch. This post covers what Superpowers actually is, how the methodology works, what v7.0.0 changed, and an honest split of which productivity claims are verified versus anecdotal.

## What Is Superpowers (the Agentic Skills Framework)?

Superpowers is a collection of structured "skills," markdown instruction files with mandatory invocation rules, that install into a coding agent and change how it approaches a task. It's not a tool you call. It's a methodology the agent is compelled to run. The repository ships under an MIT license, carries 684 commits, and installs as a one-line plugin. The canonical phrase to know is its own name plus its tagline: an agentic skills framework and software development methodology.

![Lines of colorful JavaScript code displayed on a dark screen](https://cdn.sanity.io/images/vzekdneq/production/c955d26de8fdb0429f885023f8c4ab5de0a88174-1200x675.webp)

The core idea is deceptively plain. Left alone, a model like the one behind [Claude Code](/blog/github-copilot-vs-claude-code) tends to sprint to code, skip tests, and lose the thread on longer tasks. Superpowers intercepts that reflex. When you give it work, the framework pushes the agent through a fixed sequence before a single line of production code gets written:

- **Brainstorm** the problem and surface your real intent, not your first phrasing of it
- **Spec** the behavior in writing so there's a reference to check against
- **Plan** the implementation as discrete, verifiable steps
- **Write tests first** (test-driven development), then make them pass
- **Dispatch subagents** to execute independent pieces of the plan
- **Review in two stages** before anything merges
That's the whole product, and the restraint is the point. Superpowers didn't invent brainstorming, specs, or TDD. What it did was refuse to let the agent skip them.

> Superpowers didn't invent any of its ideas. Its genius is refusing to let the agent skip the boring, disciplined parts a senior engineer wouldn't.

This is one of those things where the boring answer is the right one. Every experienced engineer already knows that writing the test first and planning before coding produces better output. The hard part was never the knowledge. It was enforcement against a model that wants to be helpful immediately. Superpowers turns "best practice you should follow" into "behavior the agent cannot route around."

## Who Built Superpowers, and Why That Matters

None of the other write-ups mention this, which is strange, because it's the most important credibility signal in the whole story. Superpowers isn't a venture-funded tool from a team chasing a category. It's a solo project from [Jesse Vincent](https://en.wikipedia.org/wiki/Jesse_Vincent), a programmer with a 25-year open-source track record most developers have brushed against without knowing it.

![JavaScript code displayed on a dark screen with colorful syntax highlighting](https://cdn.sanity.io/images/vzekdneq/production/1b98f11a4dc52f48e669aa24dbd26367ad92d7a2-1200x675.webp)

Vincent authored Request Tracker (RT), the issue-tracking system that ran support desks across the industry for two decades. He served as the Perl 5 project lead. He founded Best Practical Solutions to sustain RT, and he co-founded the ergonomic keyboard company Keyboardio. This is someone who has spent a career building tools other people depend on and then maintaining them through the unglamorous middle years. That pedigree is why the methodology has staying power rather than a six-week hype curve. The release cadence shows it: v6.2.0 on July 24, v6.3.0 on August 12, v6.4.1 on September 19, v6.4.2 on September 25, and v7.0.0 on October 10, all in 2026. A near-monthly rhythm.

Vincent's company, Prime Radiant, also offers commercial support through a sales contact, which answers an obvious enterprise question before it's asked: there's a human on the other end if a team needs one.

## How Superpowers Works: Brainstorm → Plan → TDD → Subagent-Driven Review

The methodology is where the agentic skills framework earns its keep, so it's worth walking the phases as the agent experiences them.

It starts with **brainstorming**, and v7.0.0 rebuilt this phase entirely. The agent interrogates your request before accepting it. You ask for "a dashboard"; it asks what the dashboard is for, who reads it, what happens when data is missing. This feels like friction on a trivial task and like salvation on a real one. Surfacing intent early is the single cheapest way to avoid building the wrong thing correctly.

Next comes **planning and spec-writing**. The agent produces a written plan and a behavioral spec. This artifact matters more than it looks: it becomes the thing the later review phase checks against, so "did the agent do what we agreed?" has an objective answer instead of a vibe.

Then **test-driven development**. The agent writes failing tests that encode the spec, then writes code until they pass. This is the phase [Simon Willison](https://simonwillison.net/guides/agentic-engineering-patterns/code-is-cheap/) singled out when he called TDD "the key methodology used by the popular superpowers set of Claude skills by Jesse Vincent," citing it as evidence that test-first discipline produces better results from coding agents. Willison's endorsement carries weight precisely because he's skeptical of tooling by default.

After that, **subagent-driven development**, the piece that gives Superpowers its distinctive flavor. Independent chunks of the plan get dispatched to separate subagents, each working in a constrained context, then their output is reconciled. This mirrors how I run things on my own stack. Running this blog's seven-agent publishing pipeline taught me that model-per-job-shape beats one-model-everywhere: a tool-loop agent and a prose agent want different models and different context budgets, and pretending otherwise costs you on both quality and spend.

Finally, **two-stage review** before merge. The work is checked once, revised, and checked again. The discipline here is the same reason I lean on deterministic gates in my own pipeline. A cheap mechanical check that runs before the expensive [LLM](/glossary/llm) reviewer catches more than simply doubling the size of the review model would. Superpowers bakes that layering into the workflow instead of leaving it to the operator.

The net effect is that the agent behaves less like an autocomplete on steroids and more like a junior engineer who has been handed a checklist and isn't allowed to lose it halfway through.

## The Skills Library: What Each Skill Actually Does

Under the hood, Superpowers installs a set of discrete skills into the agent. Independent explainers have counted roughly 14 structured skills grouped into practical categories, and the newest releases keep refining them rather than piling on new ones.

| Category | What the skills in it do |
| --- | --- |
| Planning & Architecture | Brainstorm intent, write specs, break work into verifiable plan steps |
| Development | Enforce test-driven development and drive implementation from the plan |
| Debugging & Quality | Systematic debugging, two-stage code review before merge |
| Documentation & Communication | Keep written artifacts and progress legible to humans and other agents |
| Operations & Workflow | Dispatch subagents, manage worktrees, sequence the overall loop |

Each skill is a markdown file with an invocation rule strong enough that the agent treats it as non-optional. That's the mechanism behind the whole thing. The skill text doesn't politely suggest running TDD; it tells the agent it must, in language blunt enough to survive the model's urge to be efficient and skip ahead. This is also the source of the framework's one consistent criticism, which I'll get to: that same mandatory language adds overhead on genuinely trivial tasks.

The skills compose. A debugging session can pull in the systematic-debugging skill, which can itself dispatch subagents, which run under the review skill. This is closer to [agent orchestration](/blog/ai-agent-swarm-coordination-patterns) than to a static prompt template, and it's why the methodology scales from a bug fix to a multi-file feature without the operator rewriting their approach each time.

## Installing Superpowers (Claude Code, Codex, Cursor, and 12+ Other Harnesses)

On Claude Code, installation is a single command: `/plugin install superpowers@claude-plugins-official`. That's it. The framework entered Anthropic's official plugin marketplace in January 2026, which is what makes the one-liner possible and signals a level of vetting most community tools never reach.

The bigger story is breadth. Earlier coverage described Superpowers as supporting "10+" agents. The current README lists **15 distinct coding-agent harnesses**: Claude Code, Antigravity, Codex App and CLI, Cursor, Devin CLI, Factory Droid, Gemini CLI, GitHub Copilot CLI, Grok Build CLI, Kimi Code, OpenCode, Pi, Qwen Code, Hermes Agent, and Muse. For the non-Claude harnesses, installation varies by platform, but the skills themselves are portable markdown, which is the entire reason one methodology can span that many tools. If you're already comparing runtimes like [OpenCode and Claude Code](/blog/opencode-vs-claude-code-token-overhead), Superpowers sits one layer above that choice rather than locking you to one vendor.

And yes, it's free. The skills, the methodology, and the plugin cost nothing under the MIT license. The only paid path is optional commercial support from Vincent's company for teams that want it. That free-and-open posture is a real part of why it spread. It answers the biggest agent complaint with a methodology instead of a subscription.

## Does Superpowers Save Tokens or Spend Them?

Here's a question none of the booster pieces answer honestly: the discipline isn't free, and it shows up on your bill. Every mandatory skill-invocation rule is text the model reads on every relevant turn, and the brainstorm-spec-plan-test sequence generates artifacts that live in context. MindStudio's April 2026 explainer leans hard on "token reduction" as a selling point, but that framing is half the story. Superpowers cuts wasted tokens on rework, since the agent builds the right thing once instead of three times, while spending more tokens up front on process.

Which way the math breaks depends entirely on task size. On a genuine feature with real maintainability stakes, the up-front spend is cheap insurance: a few thousand tokens of planning beats ten thousand tokens of an agent thrashing through a half-understood requirement. On a one-line fix, the ceremony is pure overhead. That's exactly what Agentiquette flagged when it noted the mandatory language "can add overhead on trivial tasks."

I have numbers on this. When I measured harness overhead for this site, I clocked a 4.7x token gap between two coding agents on an identical task. That's the kind of spread that makes "it's just tokens" a lazy dismissal. Run it against the current per-model rates on the [LLM pricing tracker](/llm-prices) I maintain, and a 4.7x overhead on a Claude Opus workload is the difference between a run you ignore and one you notice at month's end. Superpowers doesn't add anything close to 4.7x, but the principle holds: process has a token cost, and you should know yours before blaming the framework. If you care about [LLM cost](/blog/reduce-llm-api-costs-production) at any real volume, measure it on your own workloads instead of trusting a vendor's percentage.

That measurement discipline matters far more for teams than for solo developers, which is where the enterprise question gets real. A fleet of [AI agents](/pillars/ai-agents) running a mandatory methodology across a 20-person team multiplies both the quality win and the token spend by 20. The upside is consistency: every engineer's agent follows the same brainstorm-spec-TDD loop, so code review stops catching the same process failures over and over. I learned that lesson in a different context at Rise People, where I built SOC 2-compliant project scaffolding for the whole org. Baking the discipline into the scaffold beat reviewing for it at PR time, every single time. Superpowers is the same bet aimed at AI coding: encode the standard once in skills the agent cannot route around, and stop relitigating it in every pull request.

For teams that want a contract and a human to call, Vincent's company Prime Radiant sells commercial support. For everyone else, the methodology is free, the license is MIT, and the token math is yours to run.

## Real-World Walkthrough: Superpowers vs. Plain Claude Code

The most useful comparison in the wild is Better Stack's February 2026 case study, which built the same web application twice: once with plain Claude Code Plan Mode and once with Superpowers, then compared UI, functionality, and maintainability. The short version is that Plan Mode gets you a plan and then mostly trusts the model to follow it, while Superpowers gets you a plan, a spec, tests, subagent execution, and a review gate that checks the result against the spec. The difference shows up less in whether the app runs and more in whether the code is something you'd want to maintain in three months.

That maps onto the broader shift I keep writing about: the job is becoming [plan and review](/blog/plan-review-software-engineering) rather than typing. Superpowers is an opinionated bet on exactly that future. It front-loads the planning and formalizes the review, which is the same move good teams are making with or without a framework.

For a hands-on tour of the install and the workflow in motion, here's a full walkthrough:

[Watch: Claude Code + SUPERPOWERS = The End of Vibe Coding? (Full Tutorial)](https://www.youtube.com/watch?v=TX91PdBn_IA)

The honest caveat on any single walkthrough, including Better Stack's, is that it's one app, one developer, one afternoon. It's a strong illustration of the workflow. It is not a controlled study, and you shouldn't read it as one. If you want numbers you can trust on your own code, the move is to [benchmark the tool on your own repo](/blog/benchmark-ai-coding-tools-repo) rather than inherit someone else's demo.

## Why It Matters: The Evidence (and Its Limits)

Here's the part the booster articles skip and the critical ones overcorrect on. Both the hype and the skepticism are justified, and a reader deserves both.

The hype is real. The independent scoring publication Agentiquette audited obra/superpowers on July 7, 2026 and gave it 83 out of 100, an A-Tier rating, calling it "the most influential community skill framework for Claude Code." Its highest sub-scores were Adoption (92) and Maintenance (92), which is exactly what you'd expect from a widely-used project with a disciplined release cadence. Star growth backs this up, and the curve steepened through 2026 rather than holding flat. The repo added roughly 27,000 stars in its first three months after the October 9, 2025 launch, about 9,000 a month, then accelerated hard: ~151,000 by April 20, 2026, ~226,000 by mid-June, and 298,135 stars against 26,643 forks when I pulled the GitHub API on October 12, 2026. That works out to an average above 24,000 stars a month across its first year, with the steepest climb in spring 2026. Not the steady 9,000-a-month trickle the early figure alone would imply. Add Simon Willison's public endorsement and an official Anthropic listing, and the adoption signal is not in dispute.

The limits are also real, and they live in the same audit. Agentiquette's lowest sub-score was Evaluation Readiness, at 66, with the blunt note that "few skills ship executable tests." There's irony in a test-driven methodology whose own skills aren't well-tested. The deeper problem is the productivity numbers. Tekai.dev's April 20, 2026 review examined the headline claims (85-95% test coverage versus a 30-50% baseline, roughly 45-minute production-quality builds, and a subagent review loop dropping from about 25 minutes to 30 seconds) and found them "anecdotal and vendor-proximate," with "no independent benchmark or controlled study" comparing Superpowers-guided agents to baseline behavior on the same tasks.

That's the correct read. Those numbers almost certainly describe something real that the creator observed. They are not evidence you can plan a team rollout around, because nobody has run the controlled A/B. Based on the token-overhead testing I ran for this site, where I measured a [4.7x gap between OpenCode and Claude Code](/blog/opencode-vs-claude-code-token-overhead) on an identical task, I'd also flag the cost dimension: the mandatory skill-invocation language that disciplines the agent is itself tokens, and Agentiquette explicitly notes it "can add overhead on trivial tasks." Discipline isn't free. On a one-line change, the ceremony can cost more than the fix.

None of this makes Superpowers bad. It makes it a strong, well-maintained methodology whose benefits are plausible and whose magnitudes are unproven. Treat the specific percentages as marketing and the underlying discipline as sound, and you'll have it calibrated correctly.

## Is Superpowers Worth Installing? Who Should Use It

If you already run [agentic AI](/blog/rise-of-agentic-ai) coding agents and you're tired of them skipping tests and losing the plot, yes, install it. The cost is one command and some overhead on small tasks. The upside is a methodology that a 25-year open-source veteran designed and actively maintains, running inside whatever harness you already use. The downside risk is close to zero because it's free and MIT-licensed.

Who should skip it: anyone whose workflow is mostly tiny edits and quick scripts, where the brainstorm-spec-plan ceremony is pure drag. The framework shines on multi-step work with real maintainability stakes. It drags on one-liners. And if you were already hand-rolling a disciplined workflow with your own skills or prompts, Superpowers mostly formalizes and hardens what you built, which may or may not be worth adopting over your own version.

The influence is spreading past the repo itself. Derivative projects have already appeared. A GitHub Copilot-targeted skill suite called JDS was pitched on Show HN in May 2026 as explicitly taking "inspiration from" and trying to "improve on" obra/superpowers' core idea of enforcing agent discipline through skills. When a methodology starts getting cloned and forked for other platforms, that's the clearest market signal there is that the idea, not just the repo, has legs.

My prediction: the specific skills will matter less over the next year than the pattern they proved. "Make the agent follow a non-skippable engineering process" is going to get absorbed into the coding tools themselves, the way linting and formatting stopped being add-ons and became defaults. Superpowers won't be the last framework to enforce discipline on a coding agent. It's the one that proved a single maintainer with the right instincts could out-ship the entire paid-tool category by giving the idea away. If you're still letting your agent freestyle in 2026, the gap between you and the people running a real methodology is only going to widen.

Photo by Jakub Żerdzicki on Unsplash.

## FAQ

### Is the Superpowers plugin free to use?

Yes. Superpowers is released under the MIT license, so the skills, the methodology, and the Claude Code plugin cost nothing. The only paid option is optional commercial support from Jesse Vincent's company, Prime Radiant, aimed at teams that want a support contract.

### How many GitHub stars does obra/superpowers have?

As of October 12, 2026, the repository has 298,135 stars and 26,643 forks, pulled live from the GitHub API. It grew from about 27,000 stars three months after its October 9, 2025 launch to roughly 151,000 by April 2026 and 226,000 by mid-June — an average above 24,000 new stars a month over its first year, with growth accelerating sharply after the initial ~9,000-a-month start.

### What coding agents does Superpowers support besides Claude Code?

The current README lists 15 harnesses: Claude Code, Antigravity, Codex App and CLI, Cursor, Devin CLI, Factory Droid, Gemini CLI, GitHub Copilot CLI, Grok Build CLI, Kimi Code, OpenCode, Pi, Qwen Code, Hermes Agent, and Muse. The skills are portable markdown, which is what lets one methodology span that many tools.

### How does Superpowers compare to Claude Code's native Plan Mode?

Plan Mode produces a plan and then largely trusts the model to follow it. Superpowers adds a spec, test-driven development, subagent execution, and a two-stage review that checks the result against the agreed spec. The difference shows up most in long-term code maintainability rather than whether the app runs.

### Are Superpowers' productivity claims independently verified?

No. Independent reviewer Tekai.dev examined the headline figures, such as 85-95% test coverage versus a 30-50% baseline and 45-minute production builds, and found them anecdotal and vendor-proximate with no controlled study behind them. Treat the specific numbers as unproven and the underlying discipline as sound.

### What changed in Superpowers v7.0.0?

Version 7.0.0, released October 10, 2026, rebuilt the brainstorming skill from scratch to better surface a user's real intent before any code gets written. It continues a near-monthly release cadence that has made Maintenance one of the framework's highest independent sub-scores.