[consumer451]

I would love to know how many people are actually using superpowers.

I showed up on the agentic dev scene prior to superpowers, and I am getting concerned that >50% of my self-rolled processes are now covered by superpowers.

I no longer trust gh stars, can anyone chime in? Is superpowers now truly adopted?

If it is truly valuable, why hasn't Boris integrated the concepts yet?

[RideOnTime22]

It's just the new thing.

People were hyping up Oh My Opencode. When they realized it didn't lead to any significant gains in performance they hopped on the next thing.

And when the same thing happens to Superpowers it'll be something else they cling on because "this time it's different"

[nullstyle]

I just removed superpowers from my own setup. In my opinion, given the quality of the planning modes in both claude code and codex, superpowers was really just slowing things down and burning more tokens than vanilla.

[consumer451]

Thank you for the data point.

To give back as much as I can, I use the two built-in CC review processes when appropriate. But, those only do "is this PR good code?"

Far too late did I finally roll my own custom review skill that tests: "does this PR accomplish what the specs required?"

If I could ask for one more vanilla CC skill, it might be that. However, maybe rolling your own repo-aware skill via prompt is better?

[ramoz]

It never worked well for me. The only thing I really needed outside of the harnesses was a better plan review surface. https://github.com/backnotprop/plannotator

[horsawlarway]

anecdata, but I ended up in the same spot.

I used superpowers - but it burns waay more tokens for basically the same outcome as a single line that states

"Please do planning and ask any required questions before implementing.

[my prompt]"

On the latest models and with a decent harness, the planning modes are quite good, and the single sentence telling it to ask you questions lets the model pick the right thing to ask about, instead of wasting a bunch of time/tokens on predefined skills that try to force basically the same result.

It does introduce a second set of required interactions, but you can have another agent be your "questions answerer" if you need it (result quality goes down a bit vs answering myself, but still quite good, especially if you spend a bit of time on the answerer prompt)

Basically - things are moving fast enough I'm not convinced buying into superpowers/agentskills/[daily prompt magic beans]/etc tooling really makes sense.

I'd stick to the defaults in the harness for most cases, and then work on being clear with the ask.

[supermdguy]

I've used it off and on over the last month or so. For more complicated tasks (30+ minutes) it works well, and seems to replace a lot of prompting that I'd normally need to do (e.g. asking questions about requirements, creating specs and implementation plans, staying on task). For simple tasks, it tries to do too much and gets in the way.

[marcus_holmes]

I adopted superpowers, but then adapted it. I've changed some things, added some things. I suspect that my set of agent skills is probably overlapping with OP's by quite a lot now.

I also found that I have different skills for different tasks; at work security is a huge concern and I over-emphasise security in the skills. At play I'm less bothered about security and so the skills I've written to help me build stupid one-shot exploratory websites are less about security and more about refactoring and exploring concepts.

[DeathArrow]

>I would love to know how many people are actually using superpowers.

I use them on and off. Also Get Shit Done and Compound Engineering. The best results I got with Compound Engineering but it burns tokens like crazy, especially in the review phase where it does reviews with 5 - 12 agents in parallel - and I like to do a lot of reviews for both the plan and documentation and code.

For some lighter tasks, builtin Claude Code skills like plan mode are enough.

[alfiedotwtf]

A lover of Superpowers here, using it for about 2+ months now.

It allows you to explore the problem space upfront, it questions your assumptions, asks more probing questions to confirm what it’s found in the code, and by the time you’re ready to implement, it knows exactly what needs to happen.

Jessie should have called it Socrate’s Methods