Discussion summary
Discussions about Superpowers 6 highlight concerns over lack of benchmarking and subjective evaluation methods. Some users compare it to other tools like obra's Superpowers and GSD, with mixed opinions on its effectiveness.
What the discussion says
- Critics argue the product lacks proper benchmarks and relies on subjective assessments.
- Some users suggest it may perform better with open-source models rather than proprietary ones.
- Others believe the concept of convincing LLMs to improve is often ineffective.
“I can't take this product seriously when they don't run benchmarks.”
“This is about that, I believe.”
Join the discussion
Write your take first — we'll ask for email only when you're ready to publish.
- Hacker News
- The cool thing about superpowers is it's built using evals rather than just vibes.by ra
- I can't believe that a bunch of Markdown files now comes with a "Commercial Services" section. It feels like an elaborate GitHub Karma farm. Everything has to be commercialized and advertised.by YuukiRey
- I gave Superpowers 5.x a whirl for a week, and aside from consuming a stupid amount of tokens, it did materially worse across all my personal benchmarks and general day-to-day development compared to plain Codex/Claude. I'm convinced it's either some 4D ploy by the AI cartels to set tokens ablaze, or it only provides Superpowers to those without any power to begin with. Rating: 1/5 Pinocchios. Would not recommend.by artisin
- And the fact that this article’s story is basically “I prompted Fable with a goal and went to sleep and the model got it done” is telling me that the latest models have gotten past the need for Superpowers… even the creators of superpowers is just using a simple /goal!by jannyfer
- I found it slowed me down significantly at first, and produced more verbose code. After a few weeks of using it, I think I've gotten used to it (sometimes I explicitly bypass it, but it's good enough to know which skill to use).
Yeah on the token consumption, I'll be doing something small at work, and it'll consume a lot of tokens.
by nevi-me - It sounded like it might not hurt and seemed endorsed by Claude and codex because they both had plugins for it by default BUT I ripped it out after I kept seeing Claude/codex TDD things like when I asked them to make a pydantic model immutable. I’d end up with unit tests testing that my immutably configured pydantic model was immutable or tests that setting foo=bar was actually foo=bar in app config.
- What I like about superpowers is that for my workflow, I spend most of my time brainstorming with the claude session. Using its brainstorm mode helps to keep it from shifting to just writing code. That's basically never what I want until I actually want it. Once we've locked in a design, whatever, I don't care.
But when I don't trigger brainstorm mode, even using the built in plan mode, it's just never as in depth of a brainstorm partner for me.
by jghn - I haven't used superpowers yet, but it seems a major focus of this release was to reduce clocktime as well as token spend.
From TFA (well, blog):
> The long and the short of it it is that across about 36 hours of work and what would have been $650 of unsubsidized token spend, our Anthropic eval benchmarks were looking like we'd reduced wall-clock runtime for Superpowers builds by 50% and token spend by 60%.
by sedawkgrep - This. I found superpowers a huge token guzzler. And more generic a skill is the worse it seemed to perform. I have found that skills are something you need to build yourself and for your needs and most importantly be willing to throw away. One team I know blindly checked this into every repo they had. They also had the highest cost per pr across all teams in our org (of about 60 eng teams). AI has already given people superpowers. How sad is it that they now need to be told how to just chat and prompt and use AI effectively as a pair programmer:(by flashgordon
- 6.x feels much more efficient with respect to token usage to be fair.
I picked up superpowers back when it first started gaining traction; the first iteration felt like an “oh shit” moment for me, then the sheen quickly wore off. Higher spend, slower throughput and mediocre results made me eventually drop it and go back to plan mode, which had improved significantly during that time.
Coming back, 6.x does feel different and I’m back on the superpowers train. I’m finding it great at taking discrete tasks from beginning to end with very little hand holding.
I run every session with a /goal as well: “Spec + Plan is written and you have implemented the plan without my involvement. You have validated that the implementation is complete and ready to merge”
It’s also great in situations where you may need to complete a plan over multiple sessions, because you get a whole ton of state with superpowers that new sessions can pickup on.
by Syntaf - I'm a certified Superpowers hater. It's just not necessary with the modern models and fills up the context windows with garbage and adds an insane number of turns for no benefit.
I had similar prompts back when the models were terrible at instruction-following, so it was actually useful to fill up their context with a mass of instructions so they'd be less likely to forget rules.
Now I've got a few small slash commands or pasted prompts that work perfectly every time as the models follow them exactly.
by arcticfox - How do I know if this is worthwhile without any benchmarks against 'not using Superpowers'?by jadbox
- As a long time user, I'd recommend checking out https://github.com/obra/superpowers#the-basic-workflow. If that reasonates with you, try using it to develop a few features or capabilities.
It works very well for the way that I work (interactively and iteratively, not "one-shot"), and it helps me to better work in less time. Superpowers is one of the few skill/agent suites I use for all software development projects.
If you like building skill/agents, the posts at https://blog.fsck.com/ are a great resource for learning how to do well. The effectiveness of my project Axiom (a skill/agent suite for Apple OS developers) has benefited enormously from the knowledge that Superpowers' creator Jesse Vincent has been kind enough to share.
TLDR: You owe it to yourself to try it.
by CharlesW - I'm honestly surprised at all the people here commenting that superpowers didn't work out for them.
For me personally, it was a game changer when I first began using it and now it simply is as much a part of my workflow as any say, using git (yeah it has its warts but way way more value).
Also, the latest (version 6) is noticebly token efficient as claimed.
Did the people who found it underwhelming not try starting with the brainstorming skill first?
by devnonymous - I feel the same way. I've used superpowers since I found it during the initial Ralph hysteria and love it. Every task I do starts with brainstorming and it always produces great results, even coordinating across multiple repos. Having the plan to read and comment on ahead of time is great, although admittedly maybe that is built in to the major harnesses now and I just don't know about it. Always feel uneasy kicking off a task without having used superpowers.by sv123
- I used Superpowers for a few weeks. I ran into a couple issues:
* I wish I could turn it on selectively. Many of my requests do not require the "verification before completion" and TDD ceremony. For example, agents using stock Superpowers will go so far as to grep a file every time you ask to add something to them to verify that the edit really landed.
* While I like speccing out/designing a project before implementation (nothing new in that regard), I don't like how precisely superpowers plans out the implementation in the /writing-plans skill. It tells future agents exactly what files to edit. There are two big issues with this:
IMO, the strongest part of Superpowers is /subagent-driven-development. Yes, it's SUPER slow. For a laugh, you can ask it to make a change you know can be done in one line. It'll do it in one line, but it take literally an hour with all the verification. But that's sort of the point. It is _very_ deliberate. For each step, it reviews the step for both compliance and code quality, then has another agent implement the fixes, _and then it reviews the fixes again_. It does this for every step (not at the end of the project). While this might seem like overkill, it leads to code which complies with the spec far better.* We need to manage context rot. If one LLM session is responsible for writing out the entire plan, we aren't solving context rot. Not only is the "smart window" of context exhausted by the time the agent is planning, eg, step 7 out of 15, but it's also dragging forward all the possibly bad ideas it had earlier. It would be better if steps were planned independently. * Implementation is an iterative process. You find things out as you go. Your assumptions turned out to be wrong, you realize APIs don't behave the way you thought you did, etc. This is why writing out a precise plan ahead of time is an issue – it's written without this iteration.Instead of writing a super detailed spec, I think I'd like /writing-plans to come up with appropriate "units" of work (sometimes called slices) and to brainstorm with the user regarding implementation, but to leave it looser than "edit this exact file in this exact way". That should leave a lot more leeway to implementation agents but still give the review agents something to check compliance against.
by tmach32 - I think you can write a quick script to toggle the disable-model-invocation to turn off auto invocation.
- The screenshot of ol' claude closed code with that ascii table tells it all: Vapor AIware.
As if it really would work like that. The noise added by the verbosity alone is not taken care of enough, and this entire thing belongs on the great pile of ai vaporware.
by Amekedl - How does Superpowers compare with Matt Pocock's skills[1]? I only tried the latter, and to be honest, I had positive results without burning a quadrillion tokens.by overflowy
- Is this available in written form or even as a GitHub repository?
- apparently Matt has a upgraded version /grill-with-docsby verdverm
- I heckin love his /grill-me skill. Terse, to the point, and delivers outsized results.
Gonna take a moment to share my own generic "retro" prompt, which has found many areas of improvement IME.
> Let's conclude with a retro. Did you run into any issues during this session that you think could be improved? Any failed tool calls, confusing docs/prompts, or tricky wording that took you effort to figure out, etc? Any final thoughts that you want to raise? Anything minor you didn't mention? Help make this codebase easier for the next agent to work in.
It's somewhat doc-focused since I'm currently working on fairly dense design docs... but you can easily customize it for your own needs.
This prompt reveals how absolutely _ass_ the Claude Code harness is (so many stupid tool call failures), but not much I can do about that.
by AlexErrant - Where I $work, someone used Superpowers to pull off two big projects that before AI have always been left untouched because of the effort and time required. One was about unifying lots of duplicating (but kot exactly) libraries, and another to convert our bespoke shell scripts used throughout deployment pipeline to ansible.
When I used it though , I only found it burning too many tokens to do too little. I guess Superpowers is useful only in hands that know how to manipulate it.
by smusamashah - This is true, one has to step back and learn a new methodology. It's basically pulling our brains up and staying at the high level, and letting the Superpowers workflow do all the heavy lifting. And learning to trust that.
Similar to Addy Osmani's Agent Skills and Matt Pococks skills.
Great way to build larger projects!
by ElijahLynn - Neither the article or the corporate blog post explains what Superpowers is. Seems to be an opinionated collection of skills for dev workby dmix
- Not really - it's essentially a workflow.
The steps, described [here](https://github.com/obra/superpowers#the-basic-workflow), are: brainstorming → using-git-worktrees → writing-plans → subagent-driven-development or executing-plans → test-driven-development → requesting-code-review → finishing-a-development-branch.
The principles, described [here](https://github.com/obra/superpowers#philosophy), are: Write tests first, always; Process over guessing; Simplicity as primary goal; Verify before declaring success.
Install it, take a complex tasks, and instruct the agent to implement it; it's easier to watch it in action than to describe it.
In my own experience, the advantage is that it's a very systematic workflow - investigation of requirements, breakdown in simpler steps, and TDD development, among the other aspects.
by pizza234 - The GitHub description is a pretty good summary: "An agentic skills framework & software development methodology that works."
Here's what that methodology looks like: https://github.com/obra/superpowers#the-basic-workflow
by CharlesW - For what it's worth, I really enjoy superpowers. In particular, it does a great job with TDD that stops the model from jumping to conclusions, and I've been able to get it, even with Opus, to execute on much longer specs quite well.by prplfsh
- Superpowers feels like 20 years ago when people would be sharing and debating their incredibly elaborate .vimrc files, which totally made them super productive. Meanwhile, I tried to stick to stock configuration as much as possible (mostly for portability / ssh reasons). In a similar vein, these days some of my colleagues are sharing all their skills and prompt tricks and stuff, and I try to just use barebones Claude Code as much as possible, and I feel like it keeps getting better and better and all these prompt shenanigans are just not worth it.by losvedir
- 100% Also good to note that Cherny and Steipete have said in interviews that they keep it simple and do not use any of these shenanigans.by d4rkp4ttern