A new open-source framework called Superpowers is quietly reshaping how developers think about AI coding agents — transforming them from autocorrect-on-steroids into genuine development partners that understand what you’re actually trying to build before they write a single line of code.
Created by Jesse Vincent of Prime Radiant and available via plugin marketplaces for Claude, Cursor, Codex, and OpenCode, Superpowers is both a software development methodology and a composable library of ‘skills’ that coding agents can invoke automatically as they work.
The Problem Superpowers Solves
Most coding agents, when given a task, do exactly what you ask — immediately. They don’t step back to clarify requirements. They don’t propose a design before diving into implementation. They don’t write tests first. They don’t review their own work. The result is code that technically works but often misses the point of what the user wanted.
Superpowers addresses this by embedding mandatory workflows directly into the agent’s behavior. Before writing any code, the agent activates a brainstorming skill that asks clarifying questions, explores alternatives, and presents a design in digestible chunks for human validation. Only after the design is approved does the agent move to implementation — and even then, it does so in carefully planned increments.
How It Works
The framework centers on composable skills that trigger automatically based on context. The key skills include:
- brainstorming: Activates before writing code. Refines rough ideas through Socratic questioning, explores alternatives, and saves a design document that the human must approve before work proceeds.
- test-driven-development (TDD): Enforces a strict RED-GREEN-REFACTOR cycle. The agent must write a failing test first, watch it fail, write minimal code to pass, watch it pass, and only then refactor. Code written before tests is automatically deleted.
- writing-plans: Breaks approved designs into bite-sized tasks of 2–5 minutes each, with exact file paths, complete code, and verification steps for every task.
- subagent-driven-development: Once a plan is approved, dispatches fresh subagents per task with two-stage review — first checking spec compliance, then evaluating code quality — before moving to the next task.
- requesting-code-review: Activates between tasks. Reviews work against the plan and reports issues by severity. Critical issues block all progress.
The skills are not suggestions. They are mandatory workflows that the agent checks before any task and enforces throughout the development process.
Real Autonomy, Real Boundaries
What distinguishes Superpowers from other agent frameworks is its emphasis on human checkpoints. Subagent-driven development allows agents to work autonomously for extended periods — Vincent notes it is ‘not uncommon for Claude to be able to work autonomously for a couple hours at a time without deviating from the plan’ — but the human remains in the loop at natural breakpoints.
The framework also enforces YAGNI (You Aren’t Gonna Need It) and DRY (Don’t Repeat Yourself) principles through its skills, preventing the kind of over-engineering that plagues both human and AI-written code.
Installation and Ecosystem
Superpowers is available through the official plugin marketplace for Claude and through marketplace integrations for Cursor, Codex, and OpenCode. Installation is straightforward — for Claude Code, a single /plugin install superpowers@claude-plugins-official command pulls in the entire framework.
The framework is MIT licensed and lives entirely in a public GitHub repository, where contributors can add new skills following a detailed writing-skills guide included in the project.
Why This Matters for the AI Coding Revolution
The promise of AI coding agents has always been a world where developers describe what they want in plain English and a machine handles the implementation. Superpowers doesn’t abandon that promise — it makes it more realistic by adding the discipline that separates production-grade software from impressive demos.
As AI coding tools mature from novelties into genuine productivity tools, frameworks like Superpowers represent an important maturation of the workflow itself. The question is no longer whether an AI can write code. It’s whether an AI can write the right code — and Superpowers is one of the most thoughtful attempts yet to ensure it does.
The framework is available now on GitHub and the Claude plugin marketplace, with documentation at docs.superpowers.ai.