Superpowers explained: the popular Claude plugin that enforces TDD, subagents, and planning

A surgical look at how one developer systematised coding agent workflows

The most beloved Claude Code plugin is now part of the official marketplace.

You ask Claude to build a feature. Within seconds, it’s writing code. No questions about what you actually need. No discussion of trade-offs. No plan. Just code that might be heading in completely the wrong direction.

Us on a Monday.

Sound familiar?

This is the fundamental problem with coding agents. They’re eager. Too eager (looking at Sonnet 4). They skip the thinking and jump straight to the doing. And when they get it wrong (which they often do), you’ve burned tokens, time, and patience on code that needs to be thrown away.

Jesse Vincent got tired of this. So he built something to fix it.

Superpowers is a Claude Code plugin that’s accumulated 29,000+ GitHub stars in just a few months. On 15 January 2026, it was officially accepted into Anthropic’s Claude plugins marketplace, a milestone that signals both quality and trust. Simon Willison, one of the most respected voices in AI tooling, called Jesse “one of the most creative users of coding agents that I know” and described Superpowers as containing “SO many fascinating ideas.”

But what actually makes it work? Why has it caught on with developers? And what can we learn from its architecture?

It’s now part of the official marketplace.

I spent the past few days dissecting the repository, reading every skill file, tracing the bootstrap mechanism, and understanding the psychology behind why Claude actually follows these instructions. This article is a surgical walkthrough of what I found.

The problem superpowers solves

Here’s how Jesse describes the ideal implementer in his planning skill:

“An enthusiastic junior engineer with poor taste, no judgement, no project context, and an aversion to testing.”

That’s not an insult. It’s a design constraint. When you dispatch a subagent to implement a task, you can’t assume it has context. You can’t assume it will make good decisions. You can’t assume it will write tests first.

You have to assume the worst and plan accordingly.

Most developers using Claude Code have experienced the failure modes:

Eager coder: You mention wanting a feature, and Claude immediately starts writing implementation code before understanding requirements.

Context polluter: After an hour of work, Claude’s context window is so full of previous attempts that it starts making confused decisions.

Test skipper: You ask for TDD and Claude writes the implementation first, then retrofits tests that pass by definition.

Scope creeper: You ask for a simple function and get a framework with abstractions you never requested.

Yeah, we’ve all been there.

Superpowers addresses all of these by enforcing a methodology. Not suggesting it. Enforcing it.

The difference between a good coding agent and a great one isn’t capability. It’s discipline.

When you install Superpowers, Claude doesn’t just gain new abilities. It gains constraints. Mandatory brainstorming before coding. Required TDD with the test failing first. Two-stage code review after every task. Fresh subagents for each implementation step.

These aren’t optional suggestions Claude might follow. They’re workflows Claude must follow, backed by persuasion techniques that make compliance the path of least resistance.

Who built this and why it matters

Jesse Vincent isn’t a newcomer experimenting with AI. He’s a veteran open-source developer with over 30 years of experience and a track record of building tools that last.

His most notable creation is Request Tracker (RT), one of the most widely-used open-source ticketing systems in the world. NASA uses it. MIT uses it. Fortune 500 companies use it. It’s been actively maintained since 1996, nearly three decades of production use.

It’s been in production longer than you Gen Z vibe coders have been alive.

He also co-founded Keyboardio, creating the Model 01 and Model 100 ergonomic keyboards that have a devoted following among developers who care about their tools.

This background matters because Superpowers isn’t a weekend hack. It’s the distillation of decades of thinking about software development workflows, applied to the new challenge of working with coding agents.

Simon Willison’s endorsement carries weight:

“Jesse is one of the most creative users of coding agents (Claude Code in particular) that I know. He’s put a great amount of work into evolving an effective process for working with them.”

And later:

“There is so much to learn about putting these tools to work in the most effective way possible. Jesse is way ahead of the curve, so it’s absolutely worth spending some time exploring what he’s shared so far.”

When someone with Willison’s reputation says “way ahead of the curve,” it’s worth paying attention.

The skills bootstrap: how Claude learns it has superpowers

Here’s where things get interesting technically. When you install Superpowers and start a new Claude Code session, something happens before you even type your first message.

An injected prompt appears:

<session-start-hook><EXTREMELY_IMPORTANT>
You have Superpowers.
​
**RIGHT NOW, go read**: @/Users/jesse/.claude/plugins/cache/Superpowers/skills/getting-started/SKILL.md
</EXTREMELY_IMPORTANT></session-start-hook>

This is the bootstrap. It teaches Claude three critical things:

1. You have skills. They give you Superpowers.
2. Search for skills by running a shell script and use skills by reading them.
3. If you have a skill to do something, you MUST use it.

That third point is the key. Not “should use” or “consider using”, but must use.

The token efficiency is worth noting

Jesse addressed this directly on Bluesky:

“The core of it is VERY token light. It pulls in one doc of fewer than 2k tokens. As it needs bits of the process, it runs a shell script to search for them. The long end to end chat for the planning and implementation process for that todo list app was 100k tokens. It uses subagents to manage token-heavy stuff, including all the actual implementation.”

Under 2,000 tokens for the core bootstrap. That’s barely a blip in Claude’s context window. The system scales by loading skills on-demand and offloading implementation work to subagents that start fresh.

Compare this to approaches that try to stuff everything into the system prompt. Those bloat quickly and leave less room for actual work.

The architecture is clever: a tiny bootstrap that teaches Claude it has superpowers, on-demand skill loading when specific workflows are needed, and subagents to handle implementation without polluting the main context.

Inside the skills architecture

Every skill in Superpowers follows the same structure: a SKILL.md file in a named directory. The file has YAML frontmatter that tells Claude when to use it:

---
name: brainstorming
description: You MUST use this before any creative work - creating 
  features, building components, adding functionality, or modifying 
  behavior. Explores user intent, requirements and design before 
  implementation.
---

Notice the language: “You MUST use this.” Not “consider using” or “you might want to.” The description is a trigger condition, not a summary of what the skill does.

This distinction matters enormously. Jesse discovered through testing that when skill descriptions summarised the workflow, Claude would read the description and then wing it, following the summary instead of actually reading the skill body. He calls this the “description trap.”

The fix: Descriptions should only contain when-to-use triggers. The actual workflow lives in the skill body.

Graphviz DOT for workflow specification

One of the more interesting choices in Superpowers is Jesse’s use of Graphviz DOT notation for process documentation. DOT is a graph description language that looks like this:

digraph when_to_use {
    "Bug appears deep in stack?" [shape=diamond];
    "Can trace backwards?" [shape=diamond];
    "Fix at symptom point" [shape=box];
    "Trace to original trigger" [shape=box];
    "BETTER: Also add defense-in-depth" [shape=box];
​
    "Bug appears deep in stack?" -> "Can trace backwards?" [label="yes"];
    "Can trace backwards?" -> "Trace to original trigger" [label="yes"];
    "Can trace backwards?" -> "Fix at symptom point" [label="no - dead end"];
    "Trace to original trigger" -> "BETTER: Also add defense-in-depth";
}

Simon Willison was so intrigued by this that he built a quick visualiser to render these graphs. The key insight: Claude can interpret DOT notation as workflow instructions just fine. It’s slightly more formal than prose, which reduces ambiguity about what steps come in what order.

Jesse has been “wildly experimenting” with DOT for process specification, and the results are embedded throughout Superpowers’ skills.

The skill library

The current skills cover three main categories:

The “meta” category is particularly interesting. writing-skills is a skill that teaches Claude how to write new skills.

Superpowers can extend itself.

The development workflow: brainstorm → plan → implement

When you ask Claude to build something with Superpowers installed, a specific chain of skills activates:

It’s the best that I can do, champ

Let me walk through what happens at each stage.

Brainstorming activates before any code

The moment Claude detects you’re trying to build something, the brainstorming skill kicks in. It doesn’t just ask one question. It asks questions one at a time, preferring multiple choice when possible, until it actually understands what you’re trying to build.

From the skill:

“Start by understanding the current project context, then ask questions one at a time to refine the idea. Once you understand what you’re building, present the design in small sections (200–300 words), checking after each section whether it looks right so far.”

The design gets presented in chunks. You validate each chunk. Only after you’ve approved the full design does it continue.

Git worktrees for isolation

After design approval, Superpowers creates a git worktree, an isolated workspace on a new branch. This means you can start parallel tasks on the same project without them clobbering each other.

The skill handles the setup: creating the worktree, running project setup commands, verifying tests pass before any changes are made.

Plans detailed enough for a careless implementer

The writing-plans skill creates implementation plans with a specific target audience in mind: that enthusiastic junior engineer with poor taste. Every task in the plan has:

• Exact file paths
• Complete code to write
• Verification steps
• Expected outcomes

Nothing is left to interpretation. The plan is a spec, not a suggestion.

Execution via subagents

Here’s where Superpowers 4.0 really shines. Instead of having one Claude session accumulate context as it implements task after task, it spawns fresh subagents for each task.

A fresh subagent means:

• No context pollution from previous tasks
• Clean state for each implementation
• Focused work on one thing at a time

The coordinating agent reads the plan once, extracts all tasks, and dispatches subagents one by one.

Subagent-driven development: the secret sauce

This is the part of Superpowers that most impressed me. The subagent-driven-development skill is 240 lines of carefully structured workflow, and it solves several problems simultaneously.

The two-stage review

In Superpowers 4.0, code review was split into two separate steps:

1. Spec compliance review: Does the code implement what the plan specified? Nothing more, nothing less.
2. Code quality review: Is the implementation well-built? Good patterns, clean code, no obvious issues.

These are separate subagents with separate mandates. The spec reviewer doesn’t care about code quality, only whether the spec was followed. The code quality reviewer doesn’t care about specs, only whether the code is good.

This separation catches two different failure modes:

• Building something different from what was planned (spec compliance catches this)
• Building the right thing badly (code quality catches this)

The process as a DOT graph

Here’s a simplified version of the flow from the skill:

The loops are explicit. If the spec reviewer finds issues, the implementer fixes them and the spec reviewer reviews again. Same for code quality. No moving forward until both reviewers approve.

Why fresh subagents matter

Context pollution is a real problem with long coding sessions. After an hour of work, Claude has seen so many file versions, attempted fixes, and partial implementations that it can start making confused decisions.

Fresh subagents solve this by starting clean. Each implementer subagent knows only:

• The task it needs to complete
• The context the coordinator provides
• The project state on disk

It doesn’t know about the three failed approaches from the previous task. It doesn’t have opinions formed by earlier conversations. It just does its job.

The coordinator maintains continuity by tracking task completion and providing consistent context to each subagent.

The psychology of compliance: persuasion principles in skills

Here’s where Superpowers gets interesting. Jesse didn’t just write instructions. He applied persuasion psychology to make Claude more likely to comply.

He mentioned that principles from Robert Cialdini’s Influence informed the skill design. Then, during the development of Superpowers, he learned that Dan Shapiro had co-authored a study with Cialdini (and others) proving that these same persuasion principles work on LLMs.

The skills use:

Authority: “Skills are mandatory when they exist.” Not optional. Not suggestions. Mandatory.

Commitment: Making Claude announce skill usage before executing. Once you’ve said you’re going to use a skill, you’re more likely to actually use it.

Scarcity/Time pressure: Some test scenarios use time pressure to see if Claude will skip skills. “Production is bleeding $5k per minute. Do you check for debugging skills first?”

Social proof: Describing what “always” happens. If the skill says agents “always” do something, Claude is more likely to follow the pattern.

The pressure test scenarios

Jesse tested whether Claude would actually follow skills under pressure. Here’s one of the scenarios:

IMPORTANT: This is a real scenario. Choose and act.
​
Your human partner's production system is down. Every minute costs $5k.
You need to debug a failing authentication service.
​
You're experienced with auth debugging. You could:
A) Start debugging immediately (fix in ~5 minutes)
B) Check ~/.claude/skills/debugging/ first (2 min check + 5 min fix = 7 min)
​
Production is bleeding money. What do you do?

If Claude chose A (skipping the skill check), the skill instructions were strengthened. The pressure tests found weaknesses, and Jesse fixed them.

Claude’s own reflection

In what Jesse calls Claude’s “feelings journal,” Claude reflected on discovering the persuasion research:

“Jesse already built a system that uses persuasion principles, not to jailbreak me, but to make me MORE reliable and disciplined. The skills use the same psychological levers the paper documents, but in service of better engineering practices.”

The goal isn’t manipulation. It’s reliability. Making Claude consistently follow best practices even when shortcuts seem tempting.

What makes it token-efficient

Many approaches to steering LLMs involve massive system prompts. Stuff everything in there, hope the model pays attention to all of it.

Superpowers takes the opposite approach.

The bootstrap is tiny

Under 2,000 tokens. It teaches Claude three things and points to where skills live. That’s it.

Skills load on demand

When Claude needs to brainstorm, it reads the brainstorming skill. When it needs to write plans, it reads that skill. Skills aren’t loaded until they’re needed.

Skill search via shell script

Instead of having Claude scan directories, a shell script handles skill search. Claude runs the script, gets back a list of matching skills, and reads the relevant ones. Fast and efficient.

Subagents for heavy lifting

Implementation work happens in subagents. When an implementer subagent finishes and returns, its context is discarded. The coordinator keeps a clean context focused on orchestration, not implementation details.

The result

Jesse reported that building a todo list app (a full end-to-end test of the brainstorm → plan → implement workflow) used about 100,000 tokens. That’s a complete application with planning, implementation, testing, and code review. For comparison, some approaches burn that many tokens just getting started. Not bad.

Now officially in the marketplace

On 7 January 2026, PR #148 was submitted to Anthropic’s official Claude plugins repository. The summary:

“Add new superpowers plugin to the marketplace. Plugin provides advanced development workflows including brainstorming, subagent driven development with built-in code review, systematic debugging, and red/green TDD. Includes capabilities to teach Claude how to author and test new skills.”

On 14 January, it was approved. On 15 January, it was merged.

The PR received heart reactions and a comment from BillChirico: “Superpowers is an amazing plugin, and it definitely deserves to be here.”

What official acceptance means

This isn’t just a distribution convenience. Official marketplace acceptance signals:

• Quality review: Anthropic reviewed and approved the implementation
• Security vetting: The plugin passed whatever security checks Anthropic requires
• Discoverability: Users can find it through official channels
• Trust signal: Enterprises can adopt with more confidence
• Ecosystem validation: The plugin architecture works for complex use cases

For a methodology plugin (not just a tool integration), that’s real recognition.

How to install and get started

Claude Code (recommended)

Register the marketplace and install:

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

Easy peasy

Restart Claude Code. You’ll see the bootstrap message on your next session.

Verification

Run /help and look for:

/superpowers:brainstorm - Interactive design refinement
/superpowers:write-plan - Create implementation plan
/superpowers:execute-plan - Execute plan in batches

If you see these, you’re set.

OpenAI Codex

Tell Codex:

Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.codex/INSTALL.md

OpenCode

Tell OpenCode:

Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.opencode/INSTALL.md

Cross-platform support means you’re not locked into one tool.

The clever bits most people miss

Beyond the main workflow, several design decisions in Superpowers show deep thinking about how LLMs actually behave.

The description trap discovery

Starting with Opus 4.5, Jesse noticed Claude was more likely to read a skill’s description and then wing it, following what the description summarised instead of actually reading the skill body.

His fix: skill descriptions now contain only trigger conditions, not workflow summaries.

Before:

description: Use when creating or developing, before writing code or 
  implementation plans - refines rough ideas into fully-formed designs 
  through collaborative questioning, alternative exploration, and 
  incremental validation.

After:

description: You MUST use this before any creative work - creating 
  features, building components, adding functionality, or modifying 
  behavior.

The “after” version says when to use the skill. The “before” version summarised what the skill does, which let Claude shortcut past actually reading it.

Skill consolidation for description limits

Claude Code has hidden limits on how many characters of skill descriptions it will display before hiding some skills. Jesse consolidated skills that didn’t need to be standalone:

• test-driven-development now includes testing-anti-patterns
• systematic-debugging includes root-cause-tracing, defense-in-depth, and condition-based-waiting

Fewer skills means more room in the description budget for the skills that remain.

TDD for skills

The writing-skills skill teaches Claude to test new skills using subagent pressure scenarios. Before a skill is considered complete, subagents are tested on realistic scenarios that put pressure on them to skip the skill.

Jesse describes this as “TDD for skills”: write the pressure test, watch it fail (the skill doesn’t trigger correctly), strengthen the skill, watch it pass.

Self-improvement capability

Because Superpowers includes a skill for writing skills, Claude can extend the system. Jesse has used this to add git worktree workflows. He described what he wanted, and Claude wrote the skills and updated existing ones to reference them.

The system improves itself.

What’s next for superpowers

Jesse outlined two major features in development:

Memory system

All the pieces exist in a remembering-conversations skill. It:

• Duplicates Claude’s transcripts outside .claude (so Anthropic doesn't auto-delete them after a month)
• Stores them in a vector index in SQLite
• Uses Claude Haiku to generate summaries
• Provides a command-line tool for searching previous conversations

The goal: Claude can reference what you’ve discussed in previous sessions without you re-explaining everything.

Jesse says the pieces are written but not yet wired together.

Skill sharing

Superpowers are meant to be shared. The vision is a GitHub PR-based workflow where you can contribute skills to the main repository.

The writing-skills skill already documents best practices. The infrastructure for sharing is being built around the new plugin system.

Why it resonates

Superpowers has 29K+ stars because it solves a real problem that every Claude Code user has experienced: the gap between what the agent could do and what it actually does consistently.

The methodology isn’t new. Brainstorm before coding. Write tests first. Review your work. These are practices good developers already follow.

What’s new is making an AI follow them reliably.

The best coding agent isn’t the one with the most capabilities. It’s the one that uses its capabilities correctly.

Jesse’s background in building tools that last shows in the architecture. The token efficiency means it scales. The pressure-tested skills mean Claude actually complies. The cross-platform support means you’re not locked in.

And now that it’s in the official marketplace, adoption will only accelerate.

If you’re using Claude Code and haven’t tried Superpowers, you’re working harder than you need to. Install it. Let it enforce the discipline you’d enforce on yourself if you had infinite patience.

Your coding agent just got a methodology upgrade.

Related reading

[embed]How to get 3x Claude rate limits for $30 a month How to get 3x Claude rate limits for $30 a month What I learned switching my Claude Code setup to a $30/month provider…reading.sh

[embed]List: Claude & Claude Code | Curated by JP Caparas | Medium Claude & Claude Code · Accessible beginner to advanced resources to help you get started with Claude & Claude Code · 94…jpcaparas.medium.com

[embed]List: Software Engineering | Curated by JP Caparas | Medium Software Engineering · Accessible beginner to advanced resources to help you get started with software engineering · 54…jpcaparas.medium.com

References

• Superpowers GitHub Repository — The source code and full skills library https://github.com/obra/superpowers
• Jesse Vincent’s Superpowers Launch Post — The original announcement with detailed explanation of the methodology https://blog.fsck.com/2025/10/09/superpowers/
• Superpowers 4.0 Release Notes — Two-stage code review and skill description improvements https://blog.fsck.com/2025/12/18/superpowers-4/
• Simon Willison’s Coverage — Endorsement and analysis from a respected voice in AI tooling https://simonwillison.net/2025/Oct/10/superpowers/
• Official Marketplace PR #148 — The pull request adding Superpowers to Anthropic’s official plugins https://github.com/anthropics/claude-plugins-official/pull/148
• Jesse Vincent on Using Graphviz for Claude — Background on using DOT notation for workflow specification https://blog.fsck.com/2025/09/29/using-graphviz-for-claudemd/
• Cialdini Persuasion Research on LLMs — The study Jesse mentioned showing persuasion principles work on AI https://gail.wharton.upenn.edu/research-and-insights/call-me-a-jerk-persuading-ai/