Superpowers: The Agentic Framework Replacing Your Dev Process

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. [Updated March 2026: The repository has since grown to over 106,000 stars, with the framework now at v5.0.5 (released March 17, 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.”³ 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. A complete project reportedly used roughly 100,000 tokens total.⁴

How Does It Work?

The full Superpowers workflow runs through seven phases:

1. 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.
2. Isolated Git Worktrees — The agent creates a safe development branch, protecting main from mid-feature chaos.
3. Detailed Planning — Tasks are broken into 2–5 minute units with exact file paths, code snippets, and acceptance criteria specific enough for unsupervised execution.
4. Subagent-Driven Development — Specialized parallel subagents handle infrastructure, UI logic, and testing simultaneously, each starting with a fresh context to prevent accumulated drift.
5. Test-Driven Development — RED-GREEN-REFACTOR is enforced, not suggested. The framework “actually deletes code written before tests exist,” according to its documentation.² Tests precede implementation, period.
6. Systematic Code Review — Dedicated reviewer agents check specification compliance first, then code quality—a two-stage gate before any task closes.
7. 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.⁵

Installation

Getting Superpowers running on Claude Code takes a single command via the official plugin marketplace:

/plugin install superpowers@claude-plugins-official

To update later:

/plugin update superpowers

If you prefer the third-party marketplace, that still works too:

/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

Claude 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), and Gemini CLI (gemini extensions install https://github.com/obra/superpowers). Setup friction on non-Claude Code platforms has dropped significantly in recent releases, with v5.0.4 and v5.0.5 both shipping OpenCode-specific improvements. [Updated March 2026]

Core Commands

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–95%, according to usage reports—enterprise-level coverage achieved without code review cycles or team pressure.⁶ Parallel subagents, when properly coordinated, reportedly produce 3–4x acceleration compared to sequential single-agent approaches on multi-file features.⁶

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.⁷ TELUS teams using agentic coding workflows shipped engineering code 30% faster while accumulating 500,000 hours in total time savings.⁷ 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.⁸ 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.⁹

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?

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–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. 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.

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 106,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.

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?⁴ 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,406 new stars 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. [Updated March 2026: The repository has since surpassed 106,000 stars.]¹⁶

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⁵ offers a practical heuristic: if a feature touches three or more files, requires an architectural decision, or has meaningful 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 reportedly uses roughly 100,000 tokens total—significantly less than a naive single-session approach to the same scope.⁴

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 and Gemini 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. [Updated March 2026: v5.0.4 and v5.0.5 both shipped improvements specifically for OpenCode and Node.js 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 March 2026, the framework released v5.0.5 (March 17, 2026), confirming active maintenance. 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 meaningful bottleneck—separate from whether the code quality improves.⁴