AI Agent Skills Framework: Inside Superpowers, the 300,000-Star Repo

An AI agent skills framework called Superpowers has quietly become one of the most-starred repositories in GitHub history — over 300,000 stars, verified against the GitHub API at the time of writing, and climbing by thousands a week. If you lead an engineering team or run a business that ships software with AI coding agents, this one matters. Not because of the star count, but because of what it claims to fix: the gap between an agent that writes code quickly and one that writes code you can trust. This guide walks through what Superpowers actually is, how the workflow works, and what it means for teams adopting AI-assisted development.

For context on where this fits: Superpowers was created by Jesse Vincent (obra) and the team at Prime Radiant, first released in October 2025, and is MIT-licensed. It is not a model, not a CLI, and not a new IDE. It is a bundle of plain-markdown skills that install into your existing coding agent — Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Copilot CLI and others — and impose a disciplined software methodology on every task. Your agent just “has Superpowers”, and the skills fire automatically from the task description. No commands to memorise.

What Superpowers is, in plain terms

Think of it as two things in one package. First, a skills library: fourteen composable skills covering the full software development lifecycle — test-driven development, systematic debugging, brainstorming, writing plans, subagent-driven development, requesting and receiving code review, using git worktrees, and even a skill for writing new skills. Second, a methodology: initial instructions that force the agent to actually use those skills, in order, as mandatory workflows rather than optional suggestions.

The key design decision is automation of discipline. A raw coding agent’s default behaviour is to jump straight to editing files. That is fast and often wrong. Superpowers changes the default: the moment the agent sees you are building something, it steps back and asks what you are really trying to do. It teases a spec out of the conversation, plays it back to you in chunks short enough to read, gets your sign-off, then writes a plan and implements it under strict test-driven development. The skills trigger on their own, so the process runs the same way whether it is 9am or 11pm and whether the developer is a senior or a junior.

What it can do: the skills library

The library is organised around how work actually flows. Here are the pieces that matter most for a business evaluating it:

• Brainstorming — draws out intent before building anything, asking questions until the goal is described, then playing the understanding back for correction. Small changes get agreed in chat; real projects get a written design document a builder could plan from.
• Writing plans — breaks approved designs into bite-sized tasks of two to five minutes each, with exact file paths, complete code, and verification steps per task. Plans written “for an enthusiastic junior engineer with poor taste, no project context, and an aversion to testing” — a memorable standard that makes plans robust to weak executors.
• Test-driven development — enforces true RED-GREEN-REFACTOR. Write the failing test, watch it fail, write minimal code, watch it pass, commit. Code written before tests gets deleted. This is the famous strictness: the README’s own skill file states that code written before a failing test justifies it should not survive.
• Subagent-driven development — dispatches a fresh subagent per task with a review after each, enabling the agent to work autonomously for hours without deviating from the plan. A cheaper inline variant executes everything in one session with a single final review.
• Systematic debugging — a four-phase root-cause process with root-cause tracing, defence in depth, and condition-based waiting, plus a verification-before-completion check so the agent confirms the fix actually fixed it.
• Requesting and receiving code review — reviews against the plan, reports issues by severity, and treats critical issues as blockers. The review is adversarial: two-stage checks for spec compliance first, then code quality.
• Using git worktrees — creates isolated workspaces on new branches, runs project setup, and verifies a clean test baseline before any work begins. Parallel development branches stay out of each other’s way.
• Finishing a development branch — verifies tests, presents real options (merge, open a PR, keep, or discard), and cleans up the worktree. Sessions end cleanly instead of rotting as stale branches.

There is also a meta layer: a writing-skills skill that teaches the agent to author and test new skills, and a diagnosing-superpowers skill that reads a misbehaving session’s transcript and reports what went wrong with line-level evidence. That self-improvement loop is one reason the project keeps compounding.

How it works: the seven-step workflow

Superpowers’ basic workflow is a pipeline the agent walks through for every piece of work:

• 1. Brainstorming — activates before building. Intent is drawn out through questions before any code is discussed.
• 2. Git worktree — activates after design approval. An isolated workspace on a new branch with a verified clean test baseline.
• 3. Writing plans — activates with the approved design. Bite-sized tasks with exact paths, code, and verification steps.
• 4. Subagent-driven development — activates with the plan. Fresh subagent per task plus review, or inline execution with one final review.
• 5. Test-driven development — activates during implementation. Red, green, refactor, always.
• 6. Code review — activates between tasks. Against the plan, by severity, critical issues block.
• 7. Finish the branch — activates when tasks complete. Tests verified, options presented, worktree cleaned up.

Before any task, the agent checks for a relevant skill — and these are mandatory workflows, not suggestions. That “mandatory” distinction is the whole product: every other approach leaves discipline up to the agent’s mood; Superpowers makes it structural. This is also why it ships the same skills across fourteen-plus coding-agent harnesses rather than building yet another agent. The methodology is the asset; the harness is interchangeable.

Why it is trending: the problem it solves

Star counts measure excitement, not quality — but 300,000 stars do not appear out of nowhere. Three forces are driving the trend, and each maps to a genuine business pain:

The model is no longer the bottleneck. Frontier coding models are good enough that the limiting factor is how they are used. Teams discovered that a stronger model with no process still produces confident, untested, unreviewed code. Superpowers addresses the process layer, where most AI-assisted development actually fails in production.

Skills became the unit of agent capability. 2026 has been the year of the “agent skills” pattern: portable, composable units of behaviour that slot into any harness. Superpowers rode that wave early, and its acceptance into Anthropic’s official plugin marketplace in early 2026 — plus a dedicated bundle from Microsoft’s Amplifier project — gave it institutional distribution most open-source projects never reach.

The promise of hours of autonomous work. The subagent-driven workflow means an agent can grind through a plan for a couple of hours without drifting. For agencies and product teams, that is the difference between an assistant that needs babysitting and one that clears a backlog while developers do higher-value work. The claim is modest in marketing terms but radical in cost terms: process automation for the process itself.

Getting started: installing Superpowers

Installation differs per harness, and the README documents each one. The general pattern:

1. Pick your harness. Claude Code users install via the official plugin marketplace (/plugin install superpowers@claude-plugins-official). Codex, Cursor, Gemini CLI, OpenCode, Copilot CLI, Grok Build CLI, Kimi Code, Qwen Code and others each have their own install command in the README.
2. Install once per harness. If you use more than one agent, install Superpowers separately for each — skills do not roam between harnesses.
3. Start a session and describe what you want to build. The using-superpowers bootstrap skill loads at session start; the agent should kick off brainstorming on its own instead of jumping to code.
4. Read the design chunks before signing off. The methodology only works if the human does their part: short spec chunks are meant to be actually read, and sloppy approval produces sloppy plans.
5. Say “go” and let the pipeline run. The agent creates the worktree, writes the plan, implements under TDD with reviews, and finishes the branch.
6. Update like any package. Each harness has an update command (for example, devin plugins update superpowers for Devin CLI); the project ships release announcements you can subscribe to.

The project’s own philosophy is worth reading before you commit a team to it: test-driven development as an absolute, systematic process over ad-hoc guessing, simplicity as the primary goal, and evidence over claims — verify before declaring success.

From our experience: who gets value, and who does not

After nearly a decade of shipping software and the last few years running AI agents in real client work, here is the practitioner read. Superpowers-style discipline pays off exactly where agent failures are expensive: multi-file features, integrations, and anything that must not regress. The brainstorming gate catches the worst failure mode — the agent building the wrong thing fast — because you pay for the build and then for the rebuild.

The honest limitations matter just as much. Ceremony does not scale down. Firing the full brainstorm-plan-review pipeline on a two-line fix is slower than doing the fix. Discipline costs tokens. Fresh subagents, two-stage reviews, and verification all consume context and API spend; the cost only makes sense if the failures they prevent are expensive enough. And approval quality is the human bottleneck — if your team rubber-stamps the design chunks, the whole structure rests on a foundation nobody checked.

Our rule of thumb: adopt the methodology for feature work and refactors where a mistake costs more than the ceremony, and keep the lightweight chat-agent flow for quick fixes. Train the team on the philosophy — especially “evidence over claims” — because the tool cannot enforce what the culture does not understand. If you want help designing an AI-assisted development process around your stack, that is exactly the kind of engagement our AI integration practice runs, and our broader workflow automation work covers the operational side.

A responsible-use note before you roll it out

A methodology that makes agents dramatically more autonomous deserves a deployment checklist. Run the skills in a sandbox or containerised dev environment first — agents that create branches, run tests, and dispatch subagents have real filesystem and credential access. The README includes a telemetry section for its visual companion, so review what is collected before an enterprise rollout; if the data policy does not fit your compliance posture, disable it. Audit the skills themselves: they are plain markdown, which makes them readable — but also means a supply-chain change to the repo lands in your workflow on the next update, so pin versions rather than tracking main blindly. And keep secrets out of agent-accessible paths regardless of which skills you use. These are the same controls we apply to any agent harness in client engagements.

AI agent skills framework FAQ

Is Superpowers a coding agent itself?

No. It is a skills framework and methodology that plugs into coding agents you already use — Claude Code, Codex, Cursor, Gemini CLI, OpenCode, and others. It contains no model of its own; it makes your existing agent behave like a disciplined senior team.

What does Superpowers cost?

The open-source project is MIT-licensed and free to use. The real costs are indirect: higher token usage from subagents, reviews, and verification, plus the human time spent reading design chunks and plans. Prime Radiant offers paid commercial services — support, tooling, and managed spend — for enterprise users who want help with that layer.

Does it work with my existing coding agent?

Likely yes. The README documents installation for more than a dozen harnesses, from the major CLIs to editors and newer agents. If you use more than one, install it separately in each, since skills do not carry over between harnesses.

Is Superpowers overkill for small changes?

For a two-line fix, yes — the full brainstorm-plan-review pipeline is more ceremony than the task warrants, and the community says so openly. The value lands on feature work, integrations, and refactors, where the cost of the agent building the wrong thing dwarfs the cost of the process.

Can a business build commercial products with Superpowers-installed agents?

The framework itself is MIT-licensed, which is business-friendly — you can use, modify, and redistribute it. But the license of the framework is separate from the license of the code your agent writes and the data policies of your agent’s provider; review both before production use.

Superpowers is a rare kind of open-source project: its asset is not code but discipline, packaged as skills any agent can carry. For teams spending real money on AI-assisted development, the question it answers is the right one — not “can the agent write code?” but “can the agent be trusted with the codebase?” Explore the growing AI tools directory for more tools we are tracking, or talk to us if you want an AI-assisted development workflow designed around your team and stack.