Superpowers.
The plugin that forces
Claude to think.
Superpowers is the most-installed Claude Code plugin in the official marketplace (the "app store" for Claude Code) (163,000 GitHub stars, 4th place at Anthropic). Created by Jesse Vincent, it enforces a methodology: Claude no longer codes before it has brainstormed, planned, and tested. I just installed it. Here's what I took away after reading the docs and the feedback from advanced users: what it's good for, what it really changes, and when you're better off turning it off.
What you'll walk away with
- Superpowers forces Claude to brainstorm, write a plan, test before it codes. No more 400 lines spat out on the fly · you validate each step.
- 14 skills (reusable "trades" that Claude loads on its own) that trigger automatically depending on the context. The 3 slash commands (the shortcuts that start with
/) —/brainstorm,/write-plan,/execute-plan— are deprecated; the plugin now uses a more flexible skills system. - Honest verdict: perfect for real projects, overkill on small tasks. You turn it off with one command when you just want to test something quickly.
- Transparency · article written with Claude Code (Anthropic), reviewed and signed off by me. If you spot an error, write to me at sagnier.jeremy@gmail.com and I'll fix it.
Brand new to AI?
If some terms lose you (Claude Code, terminal, agent, MCP, skill…), start with the beginner's guide first and keep the glossary open in another tab. You'll come back here with the basics down.
Before we start
If you've been using Claude Code for a few weeks, you know the scene: you ask for something simple, Claude generates 400 lines with 10 options you never asked for, and you spend 30 minutes cleaning up. It's not Claude's fault. It's the fault of the "write me some code" format, which invites chaos.
Jesse Vincent, a former Anthropic engineer, created Superpowers to fix that. The plugin forces discipline: Claude has to understand what you want, validate the design, write a plan, then execute with tests · in that order. Released in October 2025, Superpowers climbed to 163,000 GitHub stars in six months and is the 4th most-installed plugin in the official Anthropic marketplace. Simon Willison describes it as "a significant piece in its own right." Evan Schwartz says "I can't recommend it enough."
But there are also users who complain: "Ever since I installed Superpowers, changing a bit of CSS takes three times as long" (rodskagg on Threads). Pointless overhead on small tasks. Honesty first, so I'm starting with that. For the wider context of day-to-day Claude Code use (non-dev workflow, routine, the truly expensive mistakes), I've also written my take after 6 months.
My take in 5 seconds
Superpowers is Claude Code's seatbelt. Essential when you're kicking off a serious project. Unbearable when you just want to tinker. The right stance: install it, and learn to switch it on and off on demand. You'll get the best of both worlds.
The concept · Claude gets disciplined
Superpowers doesn't add a feature. It changes the behavior of Claude Code, giving it skills that switch on automatically depending on the context.
The three pillars of the method
1. Socratic brainstorming
Instead of coding right away, Claude asks you questions. "What exactly is this for? Do you need GDPR compliance? Send immediately or scheduled?" You answer, it plays back its understanding, you confirm. Only then does it propose a design. You sign off on the design before a single line of code exists. No more drawn-out misunderstandings.
2. Test-Driven Development (TDD)
Claude first writes a test that fails, then the code that makes it pass, then it refactors (reorganizes the code without changing what it does). It's counterintuitive, but it guarantees two things: the test really checks what you wanted, and the code does exactly what it should. Zero exceptions · no "I'll test it later."
3. Subagent-Driven Development
On big projects, Claude breaks the work into independent tasks and launches several subagents in parallel ("mini-Claudes" working at the same time on different pieces). Each one does its isolated task, another agent reviews and validates it, and a third audits the quality. It's like having 3 juniors checked by a senior · but automatic.
What actually changes in your day
Before: "Do X for me" → Claude churns out code → you discover it wasn't quite what you meant → do it over.
With Superpowers: "Do X for me" → Claude questions you for 3 minutes → proposes a design → you confirm → plan written → execution tested at each step → final audit. Longer at the start, 10× faster overall.
The 14 skills in plain English (grouped by function)
The plugin activates 14 skills that trigger automatically. I've grouped them into 4 families so you can see what each one actually corresponds to.
Rather than throwing 14 names at you at random, I'll first stop on the 5 skills I actually use every week. For each one I'll tell you what it does, when it switches on by itself, and a concrete case where it saved my bacon. The other 9 are listed further down by family, catalogue-style · you'll come back to read them if you need to.
Brainstorm before you charge in · brainstorming
What it does · Claude refuses to write the first line of code until it's made you restate what you really want. It asks you between 4 and 8 questions, plays back its understanding out loud, and waits for your explicit sign-off before proposing a design.
When it switches on · Every time you start a request containing "I have an idea," "I'd like to add," "I want to build a tool that…," or when your request goes beyond 2 features. You can also force it by saying "use brainstorming to help me."
What happened to me · I wanted to add a Newsletter module to my back office. Without Superpowers, I'd have said "add me a module to manage my newsletter," Claude would have spat out a generic module with 8 fields, 5 of them useless. With brainstorming on, it asked me 6 questions: "do you want an editor or just a send? do the contacts come from Resend or from your database? scheduling or immediate send? do you need open stats? one audience or several? drafts saved locally or in the database?" Result: module delivered in 3 files exactly fitted to my use, instead of an over-engineered mess to prune afterward. 40 minutes of rewriting saved, timed on the clock.
Write a detailed plan · writing-plans
What it does · Once the brainstorm is validated, this skill turns the idea into a written plan (a Markdown file) broken into atomic tasks of 2 to 5 minutes each. Each task says which file to touch, what to put in it, and how to check it's OK. You read it, validate it, tweak it, sign off.
When it switches on · Right after brainstorming, or as soon as you launch a request that touches more than 3 files. If you say "I already have a plan in mind" and paste a rough draft, it kicks in too, to reformat it cleanly.
What happened to me · Reworking the `apprendre.html` path page of the site · 6 new cards, 4 mini-marquees to slot in, a sticky progress rail, IntersectionObserver for auto-highlight. Without a plan, Claude would have coded it all in one block and I'd have fixed everything afterward. With writing-plans, I got a `PLAN.md` file of 18 numbered tasks. I changed 2 lines (swapped the order of two steps, added an animation to the progress rail), validated it, and the execution passed on the first try. Zero backtracking on 4 hours of work.
Read a plan, critique it, execute it · executing-plans
What it does · Takes an existing plan (yours, or the one generated by writing-plans), rereads it while asking itself 4 critical questions ("what's missing? what's going to break? what hidden dependencies are there? what ordering is wrong?"), then runs it task by task, showing you the progress at each step. If a task fails, it stops instead of plowing on blindly.
When it switches on · When you paste a plan and say "execute," or when you come out of a brainstorm that produced a validated plan. Also triggered by the phrases "run it," "implement the plan," "start the execution."
What happened to me · Migrating my back office from the `admin-old/` folder to a new modular architecture, `admin/modules/`. A 23-step plan I'd written myself. When it came time to execute it, executing-plans flagged that "steps 11 and 12 have a circular dependency, you need to reverse the order, otherwise the shared shell won't be able to load the modules." I'd missed that point while writing the plan. 2 hours of debugging avoided · without that critique, I'd have broken everything halfway through and had to roll back.
Find the real cause of a bug · systematic-debugging
What it does · Forces a method in 4 mandatory phases before any attempt at a fix · (1) reproduce the bug with an exact command, (2) find the root cause (the deep cause, not the symptom), (3) write down a hypothesis and test it with a mini-script, (4) apply the fix and re-check that the bug doesn't come back somewhere else. Bans the "let me try this and see" moves that pile up regressions.
When it switches on · As soon as you say "it crashes," "it's not working," "I've got an error," "the test isn't passing anymore." Also when Claude itself botches an execution and is about to change code blind.
What happened to me · My `brainstorm.js` script (476 items scraped in parallel) was crashing silently after 30 seconds on 1 run out of 3. Without Superpowers, Claude would have tried 4 timeout / retry / try-catch fixes over 20 minutes without solving anything. With systematic-debugging, it first added a log in each parallel source, identified that it was the Hugging Face RSS feed returning malformed XML 1 time in 3, wrote the hypothesis in a `DEBUG.md` file, tested a tolerant parser, validated it. Bug fixed, never came back. Before: 3 sessions of 20 min spread over a week. After: 1 session of 25 min, done.
Have another Claude review the code · requesting-code-review
What it does · At the end of a feature, Claude launches a subagent (a fresh Claude instance that has never seen the code) dedicated to the review. That subagent compares the diff to the original plan, hunts for bugs, anti-patterns, security issues, technical debt introduced. It ranks the notes by severity (blocking / important / nice-to-have) and hands you a report.
When it switches on · Automatically at the end of a feature executed via executing-plans. Manually when you say "review what you did" or "do a code review."
What happened to me · On the `/api/subscribe.js` endpoint (the serverless function that pushes signups to Resend), Claude had written code that worked. The reviewer subagent flagged 3 points I'd have missed: "(1) you hardcode a `DEFAULT_AUDIENCE_ID` fallback that points to a third-party audience, potential data leak; (2) no handling of the Resend 409 'already subscribed', so the user gets an error even though they're subscribed; (3) no timeout on the fetch, so if Resend is slow your Vercel function costs 10x more." All 3 fixed in 12 minutes. 1 security incident avoided, 1 UX bug avoided, 1 Vercel bill kept in check. Without the review, I'd have shipped it as-is.
The other 9 skills (catalogue mode)
You don't need to memorize them · they auto-trigger when the context calls for it. Here's just what they do, so you recognize their action when you see them go by.
2 skills to support the framing phase
Document what works so you can reuse it (writing-skills) · Helps you write an instruction sheet for a procedure you do often — Claude will reuse it in future sessions.
The plugin's instruction manual (using-superpowers) · Claude reads it at startup so it knows when to activate the other skills on its own.
3 skills to run without chaos
Split into mini-Claudes that review each other (subagent-driven-development) · The heart of the plugin · each task is handed to a dedicated subagent, another checks it, a third audits it.
Launch 3 problems in parallel (dispatching-parallel-agents) · When you have 3 independent topics to sort out, Claude launches 3 agents at the same time instead of doing them one after another.
Code starting with the test (test-driven-development) · The TDD method · zero lines of code written without first setting a test that fails. Guarantees you know what to check before you start.
Work in a separate folder (using-git-worktrees) · Creates an isolated working folder (a "worktree") before you begin, so your main folder stays clean.
1 anti-regression skill
Prove it's done before saying it's done (verification-before-completion) · Before telling you "it's finished," Claude has to run the command that proves the result and read the output. No more "it should work" without proof.
2 skills to leave nothing hanging
Take feedback and know what to do with it (receiving-code-review) · When Claude gets a critique (from a human or an agent), this skill helps it judge it technically before applying it blindly.
Close a branch cleanly (finishing-a-development-branch) · Checks that all tests pass, offers 4 options · merge, open for review (a "PR," or Pull Request), keep for later, discard. Cleans up temporary files along the way.
My take after 6 weeks · the numbers
I've been using Superpowers for 6 weeks, continuously, across 4 parallel projects · this site, my local back office, my editorial brainstorm script, and the pipeline for the Jerwis Productions podcast. Over that stretch, I logged 23 sessions of more than 30 minutes (real tasks, that is, not micro-tweaks). Here's what I measured on the clock, compared to my previous 6 weeks on native Claude Code.
The raw table
| Session type | Volume | Before | After | Gain |
|---|---|---|---|---|
| New feature (3-8 files) | 9 sessions | 2 h 40 | 1 h 25 | −47 % |
| Rework of an existing module | 6 sessions | 3 h 10 | 1 h 50 | −42 % |
| Tricky debug (intermittent bug) | 4 sessions | 1 h 50 | 35 min | −68 % |
| Small fix (≤ 2 files) | 4 sessions | 12 min | 19 min | +58 % |
| Total / average | 23 sessions | 2 h 12 | 1 h 18 | −41 % |
What jumps out right away · the gain is massive on real sessions, negative on small fixes. That's consistent with what Mejba Ahmed measures (10-15 % more tokens on simple tasks). The verdict is clear-cut · you turn Superpowers on for sessions of 30 min or more, and off for quick tinkering. One command, 10 seconds, that's it.
3 real cases, timed
Case 1 · Reworking the back office Newsletter module (5 files)
Starting brief · "my current Newsletter module sends the emails but doesn't show open stats; I want to add a dashboard with open rate per send, unsubscribe rate, and a chart by month." 5 files to touch · `admin/modules/newsletter/page.html`, the router, the Resend API call, a new chart component, and the `modules.json` entry.
- Before Superpowers · 3 h 20, of which 1 h 50 was rewriting (Claude had invented a data format that didn't match what Resend actually returns).
- With Superpowers · 1 h 35, of which 12 min of brainstorm (3 questions about the source of truth for the stats, 2 on the chart format), 18 min of validated plan, 55 min of execution with no rewriting at all, 10 min of code review that flagged an API secret leaking into a log.
- Measured gain · 1 h 45 saved + 1 security incident avoided.
Case 2 · Debugging the brainstorm script that crashed 1 time in 3
Symptom · `npm run brainstorm` finished with 0 results on roughly 30 % of runs, with no error message. No obvious time pattern.
- Before Superpowers · I'd spent 2 previous sessions trying random fixes (timeouts, retry, a try-catch wrapping everything). Cumulative total · 1 h 40 with no result, the bug persisted.
- With
systematic-debugging· 32 minutes to reproduce the bug with a log per source, identify that it was the Hugging Face RSS returning malformed XML on 1 request in 3, write a tolerant parser, validate over 10 consecutive runs with no crash. - Measured gain · 1 h 08 saved + the bug finally fixed for good.
Case 3 · New feature "5-day email course" (8 files)
Brief · a capture page, a Resend endpoint that creates a contact in a dedicated audience, 5 email templates spaced 24 h apart, a tracking mechanism to measure completion, plus updating the project's CLAUDE.md.
- Before Superpowers (projected estimate based on my velocity at the time) · 4 h 30 minimum, probably with 2 or 3 round trips on the Resend sequence (I'd already struggled on the first sequence without the plugin).
- With Superpowers · 2 h 15, of which 22 min of brainstorm that surfaced a question I hadn't spotted ("if the user signs up for the newsletter AND the course, you send them 6 emails in the same week — is that OK with you, or do you want to pause the newsletter during the course?"). A 14-task plan, clean execution, and a code review that fixed a timezone bug in the scheduler.
- Measured gain · about 2 h 15 saved + 1 business decision made at the right moment.
What I hadn't anticipated
The most unexpected gain isn't the speed · it's the mental load. Before, I kept 12 things in my head during a session ("I need to check this, test that case, don't forget the API"). Now the plan is written, validated, and worked through point by point. I can step away for 5 minutes to answer an email without losing the thread. Over 6 weeks, that genuinely changes the experience.
And for a non-code project?
Superpowers has "Claude Code" in its official name, but the method (brainstorm → plan → validated execution → review) works on any structured project. I tested it on 3 non-code cases over 6 weeks. Verdict · the gains are equivalent, sometimes greater, because non-technical topics are fuzzier to begin with and the brainstorm does even more sorting.
Reworking a long article (8,000 words)
The context · I have an article on the site that was scoring 56/100 on the internal SEO audit. Too short, too surface-level, not enough real-world cases. I wanted to bring it up to 120/100 without rewriting the whole thing blind.
Without Superpowers · I'd have said "rewrite this article denser for me" and Claude would have churned out a version twice as long but not necessarily better. 2 hours of rereading to prune it.
With Superpowers · brainstorming asked me 5 questions ("which are the 3 weakest sections? which ones should you absolutely not touch? what's the exact word target? what evidence is missing? what real-world cases do you have available?"). writing-plans produced a plan of 4 intervention zones with quantified word-count targets per section. Clean execution, 1 h 10 total instead of the 3 h 30 estimated without the plugin. Gain · 2 h 20 + an article that fits exactly what I wanted.
Planning a product launch (the Skills + CLAUDE.md pack)
The context · Publishing my `jeremy-claude-pack.zip` pack (690 KB, anonymized CLAUDE.md + 26 custom skills). That involves · deciding the exact scope, writing the download page, doing 3 teaser emails, planning the 5 companion freebies, scheduling the sequence on the editorial calendar.
Without Superpowers · I'd have opened a blank Notion, listed 30 ideas, forgotten half of them, made a rough plan. Probably 2 weeks to wrap it up.
With Superpowers · brainstorming clarified the goal (newsletter acquisition or method demonstration?). writing-plans structured 14 deliverables into 4 phases with dependencies. dispatching-parallel-agents made it possible to write the 3 emails and the download page in parallel. Launch wrapped up in 4 days instead of 2 weeks, and I kept the plan as a template for future launches.
5-day email sequence (beginner AI course)
The context · Writing a free 5-day email course for the beginners who sign up. 5 emails with a teaching progression, the Leo tone respected, a different call to action each day, aligned with the rest of the site.
Without Superpowers · 5 emails written all at once, tone inconsistent between day 1 and day 5, rewriting of 3 emails out of 5. Estimated total · 4 h.
With Superpowers · Brainstorm on the exact profile (what starting level? what concrete action by the end of day 5?), a plan that sets the promise of each day before writing, execution email by email with validation, a final review that flagged 2 tone inconsistencies between days 2 and 4. 2 h 10 total, 0 rewrites after sending.
The rule for using Superpowers in non-code
You invoke the skill explicitly at the start of your request · "use brainstorming to help me get clear," or "write me a plan before you draft." Without that, Superpowers stays quiet on tasks that don't look like "code." Once invoked, the machinery chains along on its own.
What actually causes problems (honesty)
I'm not selling you a dream. The criticisms are real.
Problem 1 · Overkill on small tasks
A user on Threads: "Since Superpowers, changing a bit of CSS takes three times as long." Mejba Ahmed, in a comparative evaluation over 12 sessions, measures that simple tasks consume 10-15 % more tokens (tokens · the units the AI bills, roughly 0.75 word each) with Superpowers than with native Claude Code. The clarification + design phase is unjustified when you just want to change a color.
Problem 2 · Auto-activation too aggressive
Since a recent update, the plugin auto-invokes on everything. You just wanted to make a quick edit, and Claude launches a 5-minute brainstorming session on you. Frustrating. The fix · you turn it off on demand with claude plugin disable superpowers and turn it back on when you need it.
Problem 3 · Subagents that forget the context
Users report (issue #237 of the repo · the "repo" being the public code repository on GitHub) that subagents don't always receive the using-superpowers skill deep in the tree, which breaks the discipline you'd expect. Active bug, probably fixed in a future version.
My rule for turning it off
When I just want to test a small change (edit some text, tweak a color, try out a bit of code) · claude plugin disable superpowers. When I'm kicking off a real project or debugging a complex case · claude plugin enable superpowers. 10 seconds of management, but the plugin does its job only when it's relevant.
Install · 30 seconds flat
Step 1 · Check Claude Code
Open your terminal, type claude --version. If it responds with a number, you're ready. If not, go read my Claude Code guide first.
Step 2 · Install
claude plugin install superpowers
One single command. Installed in a few seconds from the official Anthropic marketplace.
Step 3 · Restart Claude Code
Close your Claude Code session and reopen it. The skills load at startup.
Step 4 · Test
Open any project and tell Claude "I've got an improvement idea, use superpowers to help me clarify it." It should kick off the brainstorming skill and start asking you questions. If you see that, it's installed.
My full setup
I recommend Superpowers along with the 5 other plugins I use (context7 for up-to-date docs, claude-md-management to clean up your CLAUDE.md, etc.). Everything is described in my official plugins section. The 6 install with one command each, or in one go with my bash script.
FAQ Superpowers.
Do you need to be a developer to use Superpowers?
No. I'm a non-dev and Superpowers actually has even more value in that case · the brainstorm + plan phase makes up for not having architecture instincts. Over 6 weeks of testing, my 3 non-code cases (long article, product launch, email sequence) gained as much as my code cases, sometimes more.
How many extra tokens does Superpowers cost?
On simple tasks · 10 to 15 % more tokens, according to Mejba Ahmed's comparative evaluation over 12 sessions. On real sessions of 30 minutes or more, the extra token cost is more than covered by the hours saved (-41 % on average across 23 timed sessions on my end). Simple rule · on above 30 min, off for tinkering.
How do you turn off Superpowers temporarily?
One command in the terminal · claude plugin disable superpowers. To turn it back on · claude plugin enable superpowers. Ten seconds of management on each switch, but the plugin only kicks in when it's relevant. This is the practice I recommend to anyone who finds Superpowers too heavy on small tasks.
Does Superpowers work with Cursor, or only Claude Code?
Superpowers is a plugin for the official Claude Code marketplace only, so it's not compatible with Cursor or Continue.dev as things stand. The methodology (brainstorm → plan → tested execution → review) can be applied manually in Cursor by pasting in Jesse Vincent's prompts, but without the auto-invocation and subagent orchestration that make the plugin valuable.
Is the bug where subagents forget the context fixed?
Still active as I write this article (April 2026), tracked in issue #237 of the GitHub repo. The using-superpowers skill isn't consistently loaded deep in the tree, which breaks the discipline you'd expect. Workaround · explicitly invoke the skill at the start of a nested subagent.
Superpowers vs the other Claude Code marketplace plugins?
Superpowers is the only plugin in the marketplace top 5 that changes Claude's methodology (brainstorm + plan + TDD + subagents). The other top 5 (context7, claude-md-management, frontend-design, code-review) add one-off capabilities. All 5 are complementary, not competitors · I use all 5 in parallel on the same Claude Code Max setup.
How long does it take to get the hang of Superpowers?
Figure on 1 week to identify the 5 skills you actually use every week (brainstorming, writing-plans, executing-plans, systematic-debugging, requesting-code-review). Figure 2 to 3 weeks before you get the reflex of turning the plugin off for small fixes. After 6 weeks, you're driving the tool instead of being driven by it.
Does Superpowers work for non-code projects?
Yes, and often better. The brainstorm + plan + validated execution method is universal. My 3 non-code cases tested · rework of an 8,000-word article (saved 2 h 20), planning a product launch (4 days instead of 2 weeks), a 5-day email sequence (2 h 10 instead of an estimated 4 h). Tip · invoke the skill explicitly at the start ("use brainstorming to help me get clear").
What are the 3 main criticisms of Superpowers?
Three honest, measurable criticisms · (1) overkill on small tasks (+10-15 % tokens, +58 % time on fixes of 2 files or fewer), (2) auto-invocation too aggressive since a recent update, (3) subagents that forget the context deep in the tree (issue #237). All 3 can be worked around · turn it off on demand, invoke explicitly, or follow the GitHub issue.
How do you install Superpowers in 30 seconds?
Three steps · (1) check Claude Code is installed via claude --version, (2) run claude plugin install superpowers from the official Anthropic marketplace, (3) restart Claude Code to load the skills. Test · open a project and say "use superpowers to help me clarify my idea." If Claude asks questions instead of coding, it's installed.
Going further
Superpowers is a big topic · here's what I recommend to dig deeper:
- Jesse Vincent's founding post · understand the philosophy from the author himself. It's in English and reads very well.
- Simon Willison on Superpowers · the go-to authority in the AI-dev world gives his take. Short, precise, honest.
- Mejba Ahmed's evaluation · 12 real sessions measured. More useful than a marketing review.
- Official Claude Code plugins doc (Anthropic) · the full marketplace, and how to publish your own plugin.
- My take on Claude Code after 6 months · the non-dev usage context that makes Superpowers genuinely relevant.
- Claude Code loops explained · understand the inner loop that makes skill orchestration possible.
- My 6 official plugins · Superpowers + the 5 others that make up my stack.
- My Tools page · the 6 tools I use every day, beyond the plugins.
If you install Superpowers this week and hit a case where it really saved your bacon (or the opposite · it frustrated you), reply to my newsletter and tell me about it. I do the same thing all the time · I learn from field feedback. I can be wrong about your needs, and your messages set me straight.
Shall we keep going?
I test AI for real and share what works, without jargon or hype. If this article was useful to you, the easiest way to never miss anything is my Friday letter. And if you have a question or a doubt: reply to me, I read everything.