Superpowers is an open-source agentic skills framework that transforms AI coding agents into disciplined software engineers by enforcing non-negotiable workflows: design before code, tests before features, and structured review between every task. Created by Jesse Vincent in October 2025 and accepted into the Anthropic marketplace in January 2026, it accumulated over 27,000 GitHub stars in its first three months, roughly 9,000 per month. By mid-June 2026 the repository had grown to over 226,000 stars [Updated June 2026], with the framework at v5.1.0 (released May 4, 2026) [Updated June 2026], and it remains a default install for many Claude Code power users into Q2 2026. (Pillitteri, Pasquale. “Superpowers for Claude Code: Complete Guide 2026.” pasqualepillitteri.it, 2026)
What Is Superpowers?
Most developers using AI coding agents have hit the same wall: the model starts strong, drifts after a few turns, loses context across files, and ships code that compiles but misses the spec. Superpowers is Jesse Vincent’s answer to that drift: 30 years of software development methodology distilled into composable “skills” that AI agents activate automatically based on context.
A skill in this framework is a markdown file. Each file describes a specific workflow: when to trigger it, what steps to follow, what outcomes to verify. The framework ships with skills for brainstorming, planning, test-driven development, systematic debugging, Git worktree management, code review, and subagent-driven development. Agents don’t pick and choose which processes to follow; the framework makes them mandatory.
Jesse Vincent describes the ambition plainly on his blog: “An implementation plan that’s clear enough for an enthusiastic junior engineer with poor taste, no judgement, no project context, and an aversion to testing to follow.” (Vincent, Jesse. “Superpowers: How I’m using coding agents in October 2025.” blog.fsck.com, October 9, 2025) That’s the target audience for every plan the system produces, not the AI, which Vincent clearly trusts less than that hypothetical junior hire.
Simon Willison, writing about the framework at launch, called Vincent “one of the most creative users of coding agents” and highlighted the system’s token efficiency: despite its comprehensiveness, it remains “token light,” pulling minimal documentation into the main context while using subagents to handle implementation details. Willison reports a complete project used roughly 100,000 tokens total. (Willison, Simon. “Superpowers: How I’m using coding agents in October 2025.” simonwillison.net, October 10, 2025)
How Does It Work?
The full Superpowers workflow runs through seven phases:
- Socratic Brainstorming: Before any code is touched, the agent asks clarifying questions about requirements, edge cases, and technology choices. The session produces a design document you approve in chunks.
- Isolated Git Worktrees: The agent creates a safe development branch, protecting main from mid-feature chaos.
- Detailed Planning: Tasks are broken into 2 to 5 minute units with exact file paths, code snippets, and acceptance criteria specific enough for unsupervised execution.
- Subagent-Driven Development: Specialized parallel subagents handle infrastructure, UI logic, and testing simultaneously, each starting with a fresh context to prevent accumulated drift.
- Test-Driven Development: RED-GREEN-REFACTOR is enforced, not suggested. The framework “actually deletes code written before tests exist,” according to its documentation. (ByteIota. “Superpowers Agentic Framework: 27K GitHub Stars.” byteiota.com, 2026) Tests precede implementation, period.
- Systematic Code Review: Dedicated reviewer agents check specification compliance first, then code quality, a two-stage gate before any task closes.
- Branch Completion: The agent handles integration, comprehensive testing, and documentation before signaling done.
The practical effect, as practitioner Richard Joseph Porter reports: features spanning 15+ files now “execute consistently without losing earlier decisions.” He estimates timeline predictability improves significantly when work is decomposed into discrete tasks with unambiguous criteria. (Porter, Richard Joseph. “Superpowers Plugin for Claude Code: How I Ship Big Features with Confidence.” richardporter.dev, 2026)
Installation
Getting Superpowers running on Claude Code takes a single command via the official plugin marketplace:
/plugin install superpowers@claude-plugins-officialTo update later:
/plugin update superpowersIf you prefer the third-party marketplace, that still works too:
/plugin marketplace add obra/superpowers-marketplace/plugin install superpowers@superpowers-marketplaceClaude Code is the primary target platform, but Superpowers now runs on Cursor (/add-plugin superpowers or search the plugin marketplace), Codex, OpenCode (fetch setup instructions via the agent: Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.opencode/INSTALL.md), Gemini CLI (gemini extensions install https://github.com/obra/superpowers), and GitHub Copilot CLI. Setup friction on non-Claude Code platforms has dropped significantly in recent releases, with v5.0.4 through v5.0.7 shipping OpenCode-specific improvements, Cursor camelCase hooks, and Copilot CLI tool mapping. (Pillitteri, Pasquale. “Superpowers for Claude Code: Complete Guide 2026.” pasqualepillitteri.it, 2026)
Core Commands
| Command | Function |
|---|---|
/using-superpowers | Activates Superpowers context |
/superpowers:brainstorm | Initiates requirements dialogue |
/superpowers:write-plan | Generates detailed task plan |
/superpowers:execute-plan | Launches parallel subagent execution |
Why Does It Matter? The Evidence
The question behind any new dev methodology is whether the structure pays for itself. The data here is mixed but directionally useful.
Where It Helps
When TDD enforcement is active, test coverage typically reaches 85% to 95% according to usage reports, enterprise-level coverage achieved without code review cycles or team pressure. (Pillitteri, Pasquale. “Superpowers for Claude Code: Complete Guide 2026.” pasqualepillitteri.it, 2026) Parallel subagents, when properly coordinated, produce 3x to 4x acceleration compared to sequential single-agent approaches on multi-file features. (Pillitteri, Pasquale. “Superpowers for Claude Code: Complete Guide 2026.” pasqualepillitteri.it, 2026)
The broader agentic context supports the case for structure. Anthropic’s 2026 Agentic Coding Trends Report documents that Claude Code completed a task in a 12.5-million-line codebase in seven hours of autonomous work, achieving 99.9% numerical accuracy. (Anthropic. “2026 Agentic Coding Trends Report.” resources.anthropic.com, 2026) TELUS teams using agentic coding workflows shipped engineering code 30% faster while accumulating 500,000 hours in total time savings. (Anthropic. “2026 Agentic Coding Trends Report.” resources.anthropic.com, 2026) These results emerged from teams that had established clear workflows and oversight patterns, not from unconstrained agent autonomy.
The Productivity Paradox
Superpowers exists partly in response to a counterintuitive finding that unsupervised agentic development has surfaced repeatedly: AI tools don’t automatically make experienced developers faster. A July 2025 METR randomized controlled trial found that experienced open-source developers working on their own repositories were 19% slower when using AI tools. (METR. “Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity.” metr.org, July 10, 2025) Developers predicted AI would save them 24% of time; the actual result was the opposite.
A separate Anthropic study found developers scored 17% lower on comprehension tests when learning new coding libraries with AI assistance, raising concerns about skill formation and cognitive debt alongside raw productivity metrics. (Tessl. “Anthropic: 8 agentic coding trends shaping software engineering in 2026.” tessl.io, 2026)
Superpowers directly addresses both failure modes. The mandatory brainstorming phase forces developers to articulate requirements before delegating, preventing the cognitive offloading that degrades understanding. The structured review gates prevent AI-generated code from bypassing the learning and verification that keep developers competent.
The Framework Landscape
How does Superpowers fit within the broader field of agentic development tools?
| Framework | Primary Use | Methodology | Best For |
|---|---|---|---|
| Superpowers | Claude Code/Codex agent discipline | Skills-based enforcement | Complex multi-file features, TDD mandates |
| LangChain | LLM application chaining | Pipeline orchestration | Multi-step LLM workflows |
| LangGraph | Stateful agent graphs | Graph-based state machines | Complex agent coordination |
| CrewAI | Multi-agent teams | Role-based collaboration | Research, analysis tasks |
| AutoGen | Conversational agents | Multi-agent dialogue | Code generation, debugging |
| Semantic Kernel | Enterprise integration | Plugin-based skills | Microsoft ecosystem |
The distinction is purpose: LangChain, LangGraph, and CrewAI are infrastructure for building agentic systems. Superpowers is a methodology for using an existing agentic coding agent more effectively. They operate at different layers of the stack and aren’t direct competitors.
The v5.x Milestone and What Changed
Superpowers crossed a significant threshold with its v5 releases in March 2026. The jump from the v1 to v4 era, which focused on Claude Code as the single target, to v5 reflects a deliberate platform strategy: support every major agentic coding environment rather than optimize for one. The v5.0.4 and v5.0.5 releases (both March 17, 2026) shipped OpenCode-specific installation refinements and fixed a brainstorming server ESM compatibility issue on newer Node.js versions. Subsequent releases through v5.0.7 (March 31, 2026) added a zero-dependency brainstorm server with native RFC 6455 WebSockets, Cursor support with camelCase hooks, Claude Code to Copilot CLI tool mapping with SessionStart context injection, and an integrated Spec Self-Review checklist that catches four to five bugs in about thirty seconds. The subagent review loop was replaced with inline self-review, cutting execution time from roughly twenty-five minutes. The framework now documents twelve skills structured in phases. (Pillitteri, Pasquale. “Superpowers for Claude Code: Complete Guide 2026.” pasqualepillitteri.it, 2026)
That last fix matters: the brainstorming phase is the framework’s most differentiating feature, and a broken brainstorm server would have silently degraded the core value proposition for anyone on a modern Node runtime.
v5.1.0 (May 4, 2026) pushed the platform-agnostic approach further. [Updated June 2026] The legacy slash commands (/brainstorm, /execute-plan, /write-plan) were formally removed — they had been deprecated forwarding stubs since v5.0.x. More substantively, the dedicated superpowers:code-reviewer named agent was eliminated: its persona and checklist were merged into a self-contained Task-dispatch template, reducing platform footprint and eliminating a compatibility surface that had caused friction on non-Claude Code hosts. Git worktree handling was reworked to take advantage of first-class worktree support now present in both Claude Code and Codex — provenance-based cleanup was tightened to only remove worktrees created by Superpowers, and merge-then-remove ordering was fixed to prevent detached HEAD states. Factory Droid was added as a supported platform. (Vincent, Jesse. “Superpowers 5.1.0.” blog.fsck.com, May 4, 2026)
The version jump also signals something about Superpowers’ competitive position. Early adopters used it as a personal productivity layer on Claude Code. The v5 architecture treats it more like a methodology standard that different agent runtimes can implement. If that framing takes hold, Superpowers would occupy a category-defining position: not just a popular plugin, but a reference implementation for how disciplined agentic coding should work across tools.
An Emerging Comparison: Methodology-as-Plugin vs. Autonomous Agents
The more interesting competitive tension in early 2026 is not Superpowers vs. LangChain; it’s Superpowers vs. fully autonomous coding agents like OpenHands (formerly OpenDevin) and Cognition’s Devin. These tools take the opposite design philosophy: rather than enforcing human-approved planning gates, they pursue end-to-end autonomy with minimal checkpoints.
The tradeoff is measurable in practice. Autonomous agents excel on well-scoped, bounded tasks with clear acceptance criteria, the kind that SWE-bench benchmarks capture. Superpowers excels on open-ended features where scope creep and context drift are the dominant failure modes. Neither approach dominates universally, and some practitioners run both: autonomous agents for isolated ticket-style work, Superpowers for architectural features requiring coordinated judgment across sessions.
What the 226,000-star trajectory suggests is that a substantial developer cohort has concluded the planning gates are worth it, at least for the class of work where autonomous agents still fail unpredictably.
The Expanding Host Landscape (Mid-2026)
When Superpowers launched in October 2025, Claude Code was the only meaningful target. By mid-2026, the host landscape has broadened enough that the framework’s multi-platform strategy is no longer forward-looking — it’s a practical requirement. Windsurf 2.2 now bundles an autonomous review agent in every self-serve plan, competing directly with Superpowers’ two-stage review gate for Windsurf users. Amazon’s Kiro, released in June 2026, ships with built-in spec and steering documents that formalize requirements before coding begins — independently arriving at the same design-before-code philosophy Superpowers enforces, though as IDE-native scaffolding rather than an installable methodology layer. GitHub Copilot Workspace moves in the opposite direction, emphasizing end-to-end autonomy with a task decomposition step that stays inside the Copilot UI rather than exposing it to the developer for approval.
These divergences clarify what Superpowers is selling: not autonomy, but structured human checkpoints. Each competing tool embeds its own opinion about how many gates to include and who controls them. Superpowers’ answer — developer-approved design documents, mandatory test-before-code, two-stage review — is the most conservative of the major options, which is both its main limitation and its main selling point for teams where AI-generated code bypassing review has already caused production incidents. For teams evaluating the full range of agentic coding assistants, the April 2026 comparison of Claude Code, Cursor, and Copilot covers the broader platform tradeoffs that Superpowers sits on top of.
What’s Proven vs. What’s Promised
The community skepticism is worth taking seriously. One Hacker News commenter raised a pointed question: if an AI model has already ingested a hundred books on test-driven development, what does feeding it a short skill file about TDD actually add? (Willison, Simon. “Superpowers: How I’m using coding agents in October 2025.” simonwillison.net, October 10, 2025) The honest answer, that the value may lie in enforcement rather than knowledge transfer, is consistent with how the framework markets itself, but it’s a hypothesis, not a measurement.
What is measurable: the growth trajectory. Twenty-seven thousand GitHub stars in the first three months, a single-day peak of 1,867 new stars on March 16, 2026 [Updated June 2026] that pushed it to #3 on GitHub trending, and official acceptance into the Anthropic plugin marketplace on January 15, 2026 all point to practitioners finding the system valuable enough to adopt and evangelize. The repository surpassed 226,000 stars by mid-June 2026 [Updated June 2026] and remained a frequently mentioned default in agent-tooling threads through Q2. (ByteIota. “Superpowers Agentic Framework: 27K GitHub Stars.” byteiota.com, 2026, Pillitteri, Pasquale. “Superpowers for Claude Code: Complete Guide 2026.” pasqualepillitteri.it, 2026)
What remains unmeasured: whether it beats a carefully designed custom prompt, whether the improvement holds across languages and codebases, and whether the cognitive overhead of managing structured workflows compounds fatigue over longer engagements.
How Practitioners Are Using It
Richard Joseph Porter’s workflow (Porter, Richard Joseph. “Superpowers Plugin for Claude Code: How I Ship Big Features with Confidence.” richardporter.dev, 2026) offers a practical heuristic: if a feature touches three or more files, requires an architectural decision, or carries real uncertainty in approach, Superpowers is worth the overhead. If a change is localized and clearly scoped, native Claude Code without the framework is faster.
This matches the framework’s own documentation. Superpowers lists its best use cases as: complex multi-file features, production code requiring high quality and test coverage, and teams frustrated with inconsistent AI agent behavior. It explicitly flags quick bug fixes and exploratory prototyping as poor fits.
The workflow structure also addresses the specific failure mode that practitioners most consistently report with unstructured agentic coding: context window exhaustion on long features. Because each subagent starts fresh with a specific, scoped task, the main session context remains clean. A complete large feature uses roughly 100,000 tokens total, according to Willison (Willison, Simon. “Superpowers: How I’m using coding agents in October 2025.” simonwillison.net, October 10, 2025), significantly less than a naive single-session approach to the same scope. For a deeper look at how Claude Code manages parallel subagent coordination at scale, see Claude Code’s dynamic workflows with parallel subagents.
Frequently Asked Questions
Q: Does Superpowers work with coding agents other than Claude Code? A: Yes, and the friction has dropped considerably. Cursor supports it via the plugin marketplace. OpenCode installation uses a dedicated INSTALL.md that the agent fetches directly from the repository. Codex, Gemini CLI, and GitHub Copilot CLI are also supported. Claude Code remains the primary target with one-command installation from the official plugin marketplace, but the others are now viable options. v5.0.4 through v5.0.7 shipped improvements specifically for OpenCode, Cursor, and Copilot CLI compatibility.
Q: Does enforcing TDD and brainstorming make Superpowers too slow for fast-moving projects? A: The overhead is real and intentional. The framework is explicitly not for prototypes or quick fixes. Practitioners recommend using it only for features touching 3+ files or requiring architectural decisions, contexts where upfront planning recovers its cost.
Q: How does Superpowers handle the token cost of parallel subagents? A: Each subagent starts with a focused, scoped context rather than the full project history. This keeps individual context windows small. Practitioner reports suggest 100,000 tokens for a complete large feature, competitive with the drift-prone single-session alternative, which burns context accumulating failed attempts.
Q: Is Superpowers maintained as Claude Code evolves? A: Yes. As of mid-2026, the framework’s latest tagged release is v5.1.0 (May 4, 2026) [Updated June 2026], and it remains in the official Anthropic plugin marketplace. The skills-as-markdown-files architecture is intentionally hackable: practitioners routinely fork and extend skills for their specific workflows.
Q: What’s the biggest practical limitation the community has identified? A: Cognitive overhead. Managing structured workflows across complex features with multiple subagents creates its own mental load. Several Hacker News respondents noted that tool proliferation in agentic development has made the cognitive burden a real bottleneck, separate from whether the code quality improves. (Willison, Simon. “Superpowers: How I’m using coding agents in October 2025.” simonwillison.net, October 10, 2025)