Superpowers: A Skill Framework That Teaches Coding Agents TDD and Code Review

Tell a coding agent to “build this feature,” and most will start writing code immediately — no tests, no design, no review. The result might look like it works, but give it a week or two and the technical debt piles up. Jesse Vincent’s Superpowers tackles this problem head-on. It’s a “skill framework and software development methodology” that forces agents to brainstorm, write specs, implement via TDD, and go through code review — all before shipping a single line of production code.

Released alongside Claude Code’s plugin system in October 2025, the project has surpassed 42,000 GitHub stars as of March 2026¹. It’s listed on Anthropic’s official plugin marketplace and supports not just Claude Code but also Cursor, Codex, OpenCode, and Gemini CLI.

Jesse Vincent — From RT to Keyboards to Agents

Understanding Superpowers starts with understanding its creator. Jesse Vincent (GitHub: obra) built Request Tracker (RT), the ticket-tracking system that became a staple of the Perl community². He founded Best Practical Solutions and maintained open-source infrastructure tools for over 20 years. In 2014, he co-founded Keyboardio to design and manufacture the ergonomic Model 01 keyboard³.

Years of maintaining RT gave him deep expertise in issue tracking and workflow automation. Building a hardware product from scratch taught him disciplined engineering habits. Both threads run directly through the design philosophy of Superpowers. As Vincent explained on his blog, Superpowers is the result of months spent working alongside coding agents — the patterns he discovered, distilled into markdown files⁴.

How It Works — Skills Drive the Agent

The core concept in Superpowers is the skill. Each skill is defined in a SKILL.md markdown file. When the agent recognizes a relevant situation, it automatically reads the corresponding skill and follows its instructions — no manual invocation needed.

After installation, starting a new session injects a bootstrap prompt telling the agent: “You have skills. If a skill exists, you must use it.” From there, the full workflow unfolds as follows:

graph TD
    A[User Request] --> B[brainstorming<br/>Socratic design refinement]
    B --> C[Spec document approved]
    C --> D[writing-plans<br/>Implementation plan]
    D --> E[git worktree<br/>Isolated branch creation]
    E --> F[subagent-driven-development<br/>Sub-agent per task]
    F --> G[Two-stage code review<br/>Spec compliance → Code quality]
    G --> H[finishing-a-development-branch<br/>Merge / PR / discard]

From Brainstorming to Spec

When the agent detects an implementation request, it doesn’t jump straight to code. Instead, the brainstorming skill activates — asking questions, exploring alternatives, and refining the design with the user. The finalized design is presented in short, human-readable sections.

Implementation Plans and TDD

Once a spec is approved, the writing-plans skill breaks the work into 2–5 minute tasks. Each task specifies exact file paths, code content, and verification steps. During implementation, the test-driven-development skill enforces the RED-GREEN-REFACTOR cycle: write a failing test first, write only enough code to pass it, and delete any code written without a test.

[!KEY] Superpowers doesn’t tell the agent “write tests first.” It tells the agent “delete any code written without tests.” Not a suggestion — an enforcement.

Subagent-Driven Development

This is the most distinctive piece. Once a plan is approved, the subagent-driven-development skill spawns a new sub-agent for each task. Each sub-agent works only on its assigned task, following TDD principles. After completion, a two-stage review kicks in:

1. Spec compliance review — verifies the implementation matches the original plan
2. Code quality review — examines code quality, patterns, and potential issues

The key benefit of this architecture is context isolation. Exploratory work — searching files, analyzing code — gets delegated to sub-agents without polluting the main agent’s context window. One Hacker News commenter described it as “using agents as tools,” calling it the key enabler for long-running autonomous work on complex tasks⁵.

Isolation via git Worktrees

The using-git-worktrees skill creates a new branch and worktree right after design approval. Multiple tasks in the same project can proceed in parallel without conflicting. When work is done, the user can choose to merge, create a PR, keep the branch, or discard it.

The Full Skill Library

The skills bundled with Superpowers fall into four categories:

How Does It Differ from AGENTS.md and Cursor Rules?

There are several ways to inject instructions into a coding agent. The most common are AGENTS.md (or CLAUDE.md), Cursor Rules (.mdc files), and Superpowers skills.

AGENTS.md is a single markdown file placed at the project root. The agent reads it at session start and treats it as an “always-on” directive — ideal for coding style guides, architecture rules, and guardrails. The downside: every instruction consumes tokens in every interaction, whether relevant or not.

Cursor Rules use the .cursor/rules/*.mdc format and support trigger types like alwaysApply, autoAttach (glob pattern matching), and agentRequested (loaded on demand). This separates static rules from dynamic ones, but it’s still limited when expressing procedural workflows.

Superpowers skills take a fundamentally different approach. Each skill lives in its own SKILL.md file and is read automatically when the agent recognizes the right context — then followed procedurally. Instead of “keep this coding style,” a skill says “once brainstorming is done, move to the planning phase.”

Cursor’s own blog acknowledged the distinction: “Compared to always-on declarative rules, skills are better suited for dynamic context discovery and procedural how-to instructions”⁶. In other words, AGENTS.md and skills aren’t competitors — they’re complementary. You can define project-wide rules in AGENTS.md while enforcing development workflows through Superpowers.

Community Reception and Real-World Limitations

Community reaction to Superpowers has been largely positive. Simon Willison published detailed analysis notes shortly after launch⁷, and Hacker News saw lively discussion. The sub-agent pattern drew the most interest — context isolation enabling long-running autonomous work was the headline appeal.

That said, clear limitations emerged. The issues most frequently raised by the community:

Token consumption explosion. Heavy sub-agent usage causes token costs to spike dramatically. One Reddit user reported that “Superpowers + Opus 4.5 produces very good code but over-engineers everything and burns through all your tokens”⁸. The consensus was that a Pro plan ($20/month) simply can’t sustain sub-agent-driven workflows.

Plan bloat. The brainstorming and planning skills sometimes overdo it. Even a small bug fix can trigger the full workflow — brainstorming → spec → plan → sub-agents — and the plan itself can grow so large that it becomes counterproductive⁹.

Skill document readability. Some developers on Hacker News pointed out that SKILL.md files are confusing for humans to read⁵. Since they’re written for agents rather than people, there’s an inherent gap between agent instructions and developer documentation.

The Bigger Picture — An Agent Skill Ecosystem Takes Shape

What makes Superpowers special isn’t just that it’s a “nice collection of prompts” — it’s that agents can write their own skills. The writing-skills skill serves as that meta-layer. Vincent shared on his blog that he had agents read programming books and extract reusable skills from them⁴. This aligns with the same “self-improving agent” pattern pursued by Microsoft’s Amplifier framework.

This trend is an extension of the agent platform wars. As Claude Code, Cursor, and Codex each introduce plugin, skill, and rule systems, the “meta-layer” that defines agent behavior has become a new competitive frontier. Superpowers has carved out its niche as a cross-platform skill framework that isn’t locked to any single vendor — which is why it consistently ranks near the top of GitHub Trending.

Conclusion — The Era of Teaching Methodology to Agents

The core insight behind Superpowers is straightforward: the problem with coding agents isn’t that they can’t write code — it’s that they don’t know software development methodology. Write tests first, validate designs, get code reviews — the same process you’d teach a junior developer needs to be taught to agents too.

42,000 stars reflect the developer community’s resonance with this approach. Token costs and over-engineering remain real concerns. But Superpowers has already proven that a future where agents work autonomously for hours — while maintaining TDD discipline and going through code review — is not just aspirational. It’s achievable.