There's a GitHub repo that amassed 264,000 stars in under a year, and its primary language isn't TypeScript or Python -- it's Shell. It doesn't build models, editors, or cloud services. It does exactly one thing: installs a complete software development methodology into your coding agent. This is obra/superpowers. As of August 1, 2026, the repo has 264,481 stars, 23,607 forks, 310 open issues, MIT license, primary language Shell, created October 9, 2025, last pushed July 31. The README opens with one sentence: "A complete software development methodology for your coding agents, built on top of a set of composable skills and some initial instructions that make sure your agent uses them." The author is Jesse Vincent, and the company behind it is Prime Radiant.
What Problem It Solves: Agents Lack Discipline, Not Intelligence
Anyone who's used Claude Code or Cursor has hit these pitfalls: you say "add a login feature," the agent immediately starts writing code, and halfway through you realize it misunderstood the requirement -- scrap and redo. Or it writes 300 lines without a single test, and you're afraid to merge. Or it loses track of the original plan mid-session, goes off-script, and builds things you never asked for. The root cause isn't that the model isn't smart enough -- it's that nothing forces the agent to think through "what to do, how to do it, and to what standard" before writing a single line. Superpowers fixes exactly this. It's not another coding agent; it's a layer of engineering discipline that sits inside your existing agent, making it step back and ask what you're really trying to do before touching code.
There are roughly three layers for managing agent behavior: static rules like system prompts or CLAUDE.md / .cursorrules that tell the agent "how to do things" but rely on self-compliance; MCP tools and plugins that give the agent "hands" but don't govern "when to act." Superpowers is the third layer: it turns engineering methodology into auto-triggering skills -- not suggestions, enforced workflows. The first two layers address "capability"; Superpowers addresses "discipline."
Core Mechanism: Ask First, Code Later
It starts working the moment you fire up your coding agent. When the agent detects you're building something, it doesn't jump into writing code. Instead, it steps back and asks what you're really trying to do. Through conversation it teases out a spec, then breaks the spec into chunks short enough for you to actually read and digest, presenting each one for confirmation. After you sign off, the agent generates an implementation plan -- in the README's words, clear enough for "an enthusiastic junior engineer with poor taste, no judgement, no project context, and an aversion to testing" to follow. The plan emphasizes three principles: TDD (write tests first), YAGNI (You Aren't Gonna Need It), and DRY (Don't Repeat Yourself). Once you say "go," it launches a subagent-driven-development process, dispatching subagents to work through each task, inspecting and reviewing their work. The README says it's not uncommon for your agent to work autonomously for a couple of hours without deviating from the plan. Crucially, these skills trigger automatically -- you don't need to manually invoke any command. Install it, and your coding agent just "has Superpowers."
The Seven-Step Workflow: From Brainstorming to Branch Cleanup
The README breaks the complete workflow into seven steps, each corresponding to a skill that triggers in sequence:
Step one, brainstorming: Activates before writing code. Refines rough ideas through questions, explores alternatives, presents design in sections for validation, and saves a design document.
Step two, using-git-worktrees: Activates after design approval. Creates an isolated workspace on a new branch, runs project setup, verifies a clean test baseline.
Step three, writing-plans: Activates with approved design. Breaks work into bite-sized tasks of 2-5 minutes each, with exact file paths, complete code, and verification steps.
Step four, subagent-driven-development or executing-plans: Activates with the plan. Dispatches a fresh subagent per task with two-stage review -- spec compliance first, then code quality; or executes in batches with human checkpoints.
Step five, test-driven-development: Activates during implementation. Enforces RED-GREEN-REFACTOR: write a failing test, watch it fail, write minimal code to pass, commit. If code was written before tests, it gets deleted and you start over.
Step six, requesting-code-review: Activates between tasks. Reviews against the plan, reports issues by severity, and critical issues block progress.
Step seven, finishing-a-development-branch: Activates when all tasks are done. Verifies tests pass, presents options -- merge, PR, keep, or discard -- then cleans up the worktree.
The README stresses: the agent checks for relevant skills before any task. These are mandatory workflows, not suggestions.
Skills Library: Four Categories Covering the Full Lifecycle
Superpowers ships skills in four categories.
Testing: test-driven-development, running the RED-GREEN-REFACTOR cycle with an attached testing anti-patterns reference.
Debugging: systematic-debugging, a four-phase root cause process with root-cause-tracing, defense-in-depth, and condition-based-waiting techniques; verification-before-completion, ensuring the problem is actually fixed before declaring success -- this directly embodies the philosophy "evidence over claims."
Collaboration is the thickest category, with nine skills: brainstorming (Socratic design refinement), writing-plans (detailed implementation plans), executing-plans (batch execution with checkpoints), dispatching-parallel-agents (concurrent subagent workflows), requesting-code-review (pre-review checklist), receiving-code-review (responding to feedback), using-git-worktrees (parallel development branches), finishing-a-development-branch (merge/PR decision workflow), and subagent-driven-development (fast iteration with two-stage review). Full coverage from thinking to delivery.
Meta: writing-skills (create new skills following best practices, with testing methodology) and using-superpowers (introduction to the skills system).
A notable trade-off: the README's Contributing section states they "don't generally accept contributions of new skills," and any skill updates must work across all supported coding agents. Skill behavior tests use the drill eval harness from the superpowers-evals project. This contrasts sharply with OpenClaw's clawhub skill store (5,400+ skills, open registration): one prefers few and curated, the other many and open.
11 Coding Agents Supported
Superpowers supports 11 coding agent harnesses: Claude Code, Antigravity, Codex App, Codex CLI, Cursor, Factory Droid, Gemini CLI, GitHub Copilot CLI, Kimi Code, OpenCode, and Pi. Each installs differently, but the approach is the same -- install Superpowers as a plugin.
Claude Code uses the official plugin marketplace: /plugin install superpowers@claude-plugins-official. Cursor uses /add-plugin superpowers. Codex CLI: /plugins then search superpowers. Codex App: click the + next to Superpowers in the sidebar. Kimi Code: find Superpowers in Marketplace, or /plugins install https://github.com/obra/superpowers. Gemini CLI: gemini extensions install. Antigravity: agy plugin install. Pi: pi install git:github.com/obra/superpowers. Factory Droid and GitHub Copilot CLI: register the marketplace first. OpenCode: let the agent fetch the install instructions itself.
One detail: if you use multiple coding agents, Superpowers needs to be installed separately in each one -- it uses each platform's native plugin mechanism, not a global proxy. The upside: switching from Cursor to Claude Code gives a consistent Superpowers experience. The methodology doesn't change with the tool.
Philosophy and Trade-offs
The README lists four philosophical principles: Test-Driven Development (write tests first, always), Systematic over ad-hoc (process over guessing), Complexity reduction (simplicity as primary goal), and Evidence over claims (verify before declaring success). These aren't empty words -- the test-driven-development skill will delete code you wrote before tests and make you start over, and verification-before-completion forces you to run verification before you can say "done."
Regarding telemetry: by default, it loads the Prime Radiant logo for brainstorming's optional visual companion from their website. The request includes only the version number -- no project info, prompts, or agent details. Set SUPERPOWERS_DISABLE_TELEMETRY to disable, and it also honors Claude Code's DISABLE_TELEMETRY opt-out.
Echo From This Project: We Use Agent-Skills Too
A personal note: building this website (aiwebcool.com), the project uses the same agent-skills mechanism -- .agents/skills holds skills like hallmark, humanizer, and humanizer-zh, and .claude/skills symlinks to them, auto-loading when the agent starts. Same idea as Superpowers: instead of humans memorizing processes, skills trigger at the right moment automatically. The difference is that Superpowers turned this into a cross-platform, eval-validated product, while we just use a simplified version in-house. Reading its README, the main takeaway is "so this can be systematized to this degree" -- turning "think before you act," which sounds like obvious advice, into a chain of executable, verifiable, reusable skills.
Who It's For, and What to Watch For
Suitable for: developers using coding agents daily who are tired of agents "writing before asking"; tech leads who want to set a unified agent workflow without building from scratch; teams practicing TDD but finding agents skip tests; anyone using multiple coding agents who wants a cross-platform methodology.
Four caveats. First, it depends on the coding agent's own plugin and subagent capabilities -- if your agent doesn't support subagents or automatic skill triggering, Superpowers won't do much. Second, "working autonomously for hours" presupposes a solid spec and plan -- garbage in, garbage out; if the plan is sloppy, the agent follows it sloppily. Third, it doesn't accept new skill contributions; for custom workflows, use the writing-skills skill to create them in your own project (they won't enter the official library). Fourth, while MIT is free, coding agent subscriptions are separate -- Claude Code ~$20/month, Cursor ~$20/month. Superpowers saves you time supervising the agent, not subscription fees. Enterprises needing commercial support, additional tooling, or managed spending can contact [email protected].
The People Behind It and the Business Model
The author is Jesse Vincent (blog.fsck.com), who posted the launch announcement on October 9, 2025. He's behind Prime Radiant (primeradiant.com), and the eval framework superpowers-evals lives under the prime-radiant-inc organization. The business logic is clear: the open-source methodology (MIT) is the free product entry point, and enterprise services (commercial support, tooling, managed spending) are the monetization path. The community is active on Discord, and new version announcements are available at primeradiant.com/superpowers/.
Superpowers isn't complicated -- it has no model code and provides no API. What it does is turn "think before you act," a basic engineering discipline, into skills that live inside your existing coding agent. Behind those 264,000 stars are people who've been burned by agents going off-script and discovered that managing the process matters more than swapping in a smarter model.
References
- Superpowers GitHub repo (264,481 stars / 23,607 forks, Shell, MIT license): https://github.com/obra/superpowers
- README (methodology positioning and skills list): https://github.com/obra/superpowers/blob/main/README.md
- Launch announcement (Jesse Vincent, 2025-10-09): https://blog.fsck.com/2025/10/09/superpowers/
- Prime Radiant company site (commercial services): https://primeradiant.com
- Eval framework superpowers-evals: https://github.com/prime-radiant-inc/superpowers-evals/