8 ms·

Superpowers 6

196 points by seahorseemoji 3mo ago

dmix 3mo ago
Neither the article or the corporate blog post explains what Superpowers is. Seems to be an opinionated collection of skills for dev work https://github.com/obra/superpowers https://github.com/obra/superpowers
- CharlesW 3mo ago
  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 https://github.com/obra/superpowers#the-basic-workflow
- pizza234 3mo ago
  Not really - it's essentially a workflow. The steps, described [here](https://github.com/obra/superpowers#the-basic-workflow 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 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.
overflowy 3mo ago
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. [1] https://www.youtube.com/watch?v=-QFHIoCo-Ko https://www.youtube.com/watch?v=-QFHIoCo-Ko
- AlexErrant 3mo ago
  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.
  - ValentineC 3mo ago
    > This prompt reveals how absolutely _ass_ the Claude Code harness is (so many stupid tool call failures) I've just started using Claude Code this month after months of Claude in VSCode + GitHub Copilot (and a bit of dabbling with AWS Kiro), and I'm actually impressed by how seemingly polished Claude Code is. I think Copilot in VSCode broke far more in my months of (ab)using it.
  - deleted 3mo ago
    [deleted]
  - ElijahLynn 3mo ago
    Side note: Matt has a new skill /grill-with-docs, which he recommends as the one to use for coding. Regular /grill-me he doesn't recommend for coding anymore.
- verdverm 3mo ago
  apparently Matt has a upgraded version /grill-with-docs https://www.youtube.com/watch?v=6BB6exR8Zd8 https://www.youtube.com/watch?v=6BB6exR8Zd8
- throwaway314155 3mo ago
  Is this available in written form or even as a GitHub repository?
cyanydeez 3mo ago
i just dont find skills work flow all that generic enough.
SoMomentary 3mo ago
I've loved Superpowers right along. I think a lot of what it does has been ingested into Claude Code proper now so I'll be interested to see if this release actually changes things up.
artisin 3mo ago
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.
- flashgordon 3mo ago
  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:(
  - marcus_holmes 3mo ago
    This. I found the original superpowers was a great start, but rewrote all those skills to fit my workflow, and iterated on that. Writing skills is the new writing code.
- sedawkgrep 3mo ago
  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%.
- Syntaf 3mo ago
  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.
rahimnathwani 3mo ago
I thought this would be about https://github.com/obra/superpowers https://github.com/obra/superpowers
- probablycorey 3mo ago
  This is about that.
ra 3mo ago
The cool thing about superpowers is it's built using evals rather than just vibes.
smusamashah 3mo ago
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.
- ElijahLynn 3mo ago
  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!
jadbox 3mo ago
How do I know if this is worthwhile without any benchmarks against 'not using Superpowers'?
- CharlesW 3mo ago
  As a long time user, I'd recommend checking out https://github.com/obra/superpowers#the-basic-workflow 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/ 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.
AIorNot 3mo ago
All these prompt and skill based git repos are sus... nothing is benchmarked -its all so subjective and unproven and breaks with model updates -everyone and his uncle has a 'secret sauce skill' -that just proves to me the subjectivity of this endeavor.
- devnonymous 3mo ago
  Ehe ... https://github.com/prime-radiant-inc/superpowers-evals https://github.com/prime-radiant-inc/superpowers-evals
devnonymous 3mo ago
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?
- sv123 3mo ago
  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.
  - shinycode 3mo ago
    Same here, the brainstorming and research phases are good and the spec part at well, I do side adversarial reviews all the time with other independent agents and feed sp the reviews and they are tools to avoid gliding over the surface. The dev process is longer but the result when done in a sound architecture with documented practices is quite good even though it’s slow. Very happy with the tool so far
losvedir 3mo ago
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.
- mgambati 3mo ago
  Ultracode is pretty good. I’m not basically using the grill-with-docs from Matt and default plan mode on Cc or codex. It’s just enough.
  - ElijahLynn 3mo ago
    Did you mean "I'm basically" (!not)?
    - mgambati 3mo ago
      Yes! Crazy typo, sorry.
  - hnhn34 3mo ago
    Is it usable on Pro plan? Seems like it would burn my rate limits immediately
- bashtoni 3mo ago
  Agreed. I often take a look at the skills and maybe take something from there to create a more minimal version that does just enough for my needs and nothing more. YAGNI is definitely the principle to be followed here. I'm sure all these people on Reddit that talk about having 5 Claude Max 20x plans and hitting the weekly limits on them all have a ton of these loaded.
- Maxion 3mo ago
  At least for me, writing the code // using the IDE // prompting the LLM to do the thing is not the hard part. The hard part is always understanding the actual problem // underlying assumptions // actual customer need and then architecturing the right solution to that. Actually implementing the solution is the easy part, and LLMs have made that now even easier. But they've not really helped interpret customer requirements when they give you logically inconsistent / unimplementable business processes that need major re-vamping before they can be coded. To some extent they can help de-code poorly worded emails sent by some exec while golfing or in a meeting. But they still can't conjure information out from nothing. Nor are they that good at helping to play the political game when you have team X and team Y depending new feature Z, but feature Z requires completely changing how either team does process Ab but neither will even admit that their processes aren't compatible with each other.
prplfsh 3mo ago
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.
mempko 3mo ago
This is great in concept but what prevents me from using it is TDD. I don't want to waste tokens on producing code that doesn't ship to the end user. Design by Contract is a far superior approach. If you've never heard of Design by Contract I don't blame you, our culture really failed to bring it mainstream. But I swear by it and it gives me real superpowers. Maybe I should fork this and gut the TDD part and replace it.
- CharlesW 3mo ago
  Nothing about Superpowers forces you to use TDD, brainstorm first, etc. It’s not rigid about the workflow.
- deleted 3mo ago
  [deleted]
- simonw 3mo ago
  What programming language are you using for Design by Contract?
  - klibertp 3mo ago
    I'd like to know, too! DbC is an actual superpower. Coupled with a gradual type system, especially one that provides type refinements (not sure if that's a Racket-specific[1] or generic term), DbC covers a wide variety of problems and either eliminates them or makes debugging them a lot easier. The problem is that only two/three languages are built around DbC (Eiffel, Racket, Ada/SPARK). There are a few others (e.g., Clojure, Raku, Scala) that provide some degree of support, but their capabilities are incredibly basic compared to what, for example, Racket offers. And for mainstream programming languages, there are libraries, but it's a coin toss whether authors even understand the idea (I once asked in a ticket for some Python contract library about contracts for callables and was met with "what?" - as if specifying range constraints on ints was all DbC was about). Unfortunately, Racket is tiny, barely a blip in the training data. In theory, you could probably get agents to a new level of reliability by making them write Racket; in practice, though, you'll burn a lot more tokens on every single edit, because the agent will need to rediscover how to do things in Racket much more often than in Python. I had some hopes that LLMs and agents based on them would be an opportunity for less popular, but technically advanced languages. So far, it doesn't seem like it's happening; the ridiculous per-token API prices mean that you need a really good agent harness for your language - and what niche PL has resources to focus on building one? [1] https://docs.racket-lang.org/ts-reference/Experimental_Features.html#(part._.Logical_.Refinements_and_.Linear_.Integer_.Reasoning) https://docs.racket-lang.org/ts-reference/Experimental_Featu...
linsomniac 3mo ago
My use case is I have them installed and let Claude decide when to use them. Looks like for my recent sessions it has been using superpowers:test-driven-development 5%, and superpowers:subagent-driven... 1%. I haven't really been working on new projects this past week though which seems to be where they fire off the most, in particular the "writing a plan" one.
johnfn 3mo ago
To be blunt I can't take this product seriously when they don't even run benchmarks. Your prompts make Claude better? Cool: prove it. Methods to evaluate LLM performance exist, they're called evals/benchmarks, and every company that is serious about AI runs them when they release a new version. (Of course benchmarks have their own issues, but squabbling over which benchmark is best and what issues there are is step 2 in being a Serious AI Company and step 1 is running them at all!) The fact that the only proof they have that 6 is better than five is a hacky table in a screenshot from Fable is, honestly, concerning.
- devnonymous 3mo ago
  To be blunt you should perhaps read the README before being condescending and dismissive. https://github.com/prime-radiant-inc/superpowers-evals https://github.com/prime-radiant-inc/superpowers-evals
  - johnfn 3mo ago
    You mean the obviously AI generated README? Did you even read it yourself?
mortsnort 3mo ago
Anyone have an opinion comparing this to GSD?
- deleted 3mo ago
  [deleted]
michelb 3mo ago
I’m a big fan of the Compound Engineering plugin from Every. As an amateur developer it helps me brainstorm, plan and implement apps very well. https://github.com/everyinc/compound-engineering-plugin https://github.com/everyinc/compound-engineering-plugin
- ValentineC 3mo ago
  I've been using Compound Engineering for the past few months too, but now that I'm seeing mention of how Superpowers consumes a lot of tokens and context, I wonder if Compound Engineering does the same. I often end my Claude Opus 1M sessions at around 60-80% context, and that's with doing `/context` once in a while, and forcing the agent to wrap up and write handover notes, so that I can start on a new unit with fresh context.
RomanPushkin 3mo ago
Superpowers is pretty much convincing LLMs they can do better. It almost never works that way.
deleted 3mo ago
[deleted]
Amekedl 3mo ago
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.
mcintyre1994 3mo ago
I think I’ve mostly found superpowers helpful, especially for TDD. It’s cool from this blog (and their GitHub) that they’ve verified it in various ways too. One issue is that I’ll sometimes see it wanting to write a whole doc for a follow on feature with a similar structure and have to tell it to just use the last one again. The most annoying thing is that it always pauses before implementing to ask if I want it to use Subagents (which it always recommends) or not.
- lucrum 3mo ago
  This is the point where I usually start a new session with a fresh context window and invoke the sub-agent development skill and just point to the spec+plan. I’d be curious to see if there was a way to automatically do this for me in Claude Code.
byzantinegene 3mo ago
seems like this would perform better with cheap open-source models on OpenCode compared to proprietary models like Claude Code or Codex.
tmach32 3mo ago
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: * 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. 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. 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.
- NorthSouthNorth 3mo ago
  I think you can write a quick script to toggle the disable-model-invocation to turn off auto invocation.
YuukiRey 3mo ago
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.
wejick 3mo ago
So far SDD (Spec Driven Development) with openspec hit the right balance for me, the Workflow is not too heavy while execution still churning good result given the spec is done well.
imgyuri 3mo ago
I feel like all these fat skills on top of agents will become stale very quickly. Unless it is for a very specific workflow with a need for deterministic outputs, I just don't see them having high value. If I do need such workflows I just use plan mode, and it is 90% sufficient. I created a skill that hooks on top of plan mode because of its shortcomings, but I'm pretty sure even this will become obsolete soon as models improve. https://github.com/oliver-im/jidoka https://github.com/oliver-im/jidoka
tomiow 3mo ago
[flagged]

196 points by seahorseemoji 3mo ago

dmix 3mo ago

Neither the article or the corporate blog post explains what Superpowers is. Seems to be an opinionated collection of skills for dev work https://github.com/obra/superpowers https://github.com/obra/superpowers

CharlesW 3mo ago
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 https://github.com/obra/superpowers#the-basic-workflow
pizza234 3mo ago
Not really - it's essentially a workflow. The steps, described [here](https://github.com/obra/superpowers#the-basic-workflow 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 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.

overflowy 3mo ago

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. [1] https://www.youtube.com/watch?v=-QFHIoCo-Ko https://www.youtube.com/watch?v=-QFHIoCo-Ko

AlexErrant 3mo ago
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.
- ValentineC 3mo ago
  > This prompt reveals how absolutely _ass_ the Claude Code harness is (so many stupid tool call failures) I've just started using Claude Code this month after months of Claude in VSCode + GitHub Copilot (and a bit of dabbling with AWS Kiro), and I'm actually impressed by how seemingly polished Claude Code is. I think Copilot in VSCode broke far more in my months of (ab)using it.
- deleted 3mo ago
  [deleted]
- ElijahLynn 3mo ago
  Side note: Matt has a new skill /grill-with-docs, which he recommends as the one to use for coding. Regular /grill-me he doesn't recommend for coding anymore.
verdverm 3mo ago
apparently Matt has a upgraded version /grill-with-docs https://www.youtube.com/watch?v=6BB6exR8Zd8 https://www.youtube.com/watch?v=6BB6exR8Zd8
throwaway314155 3mo ago
Is this available in written form or even as a GitHub repository?

cyanydeez 3mo ago

i just dont find skills work flow all that generic enough.

SoMomentary 3mo ago

I've loved Superpowers right along. I think a lot of what it does has been ingested into Claude Code proper now so I'll be interested to see if this release actually changes things up.

artisin 3mo ago

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.

flashgordon 3mo ago
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:(
- marcus_holmes 3mo ago
  This. I found the original superpowers was a great start, but rewrote all those skills to fit my workflow, and iterated on that. Writing skills is the new writing code.
sedawkgrep 3mo ago
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%.
Syntaf 3mo ago
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.

rahimnathwani 3mo ago

I thought this would be about https://github.com/obra/superpowers https://github.com/obra/superpowers

probablycorey 3mo ago
This is about that.

ra 3mo ago

The cool thing about superpowers is it's built using evals rather than just vibes.

smusamashah 3mo ago

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.

ElijahLynn 3mo ago
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!

jadbox 3mo ago

How do I know if this is worthwhile without any benchmarks against 'not using Superpowers'?

CharlesW 3mo ago
As a long time user, I'd recommend checking out https://github.com/obra/superpowers#the-basic-workflow 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/ 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.

AIorNot 3mo ago

All these prompt and skill based git repos are sus... nothing is benchmarked -its all so subjective and unproven and breaks with model updates -everyone and his uncle has a 'secret sauce skill' -that just proves to me the subjectivity of this endeavor.

devnonymous 3mo ago
Ehe ... https://github.com/prime-radiant-inc/superpowers-evals https://github.com/prime-radiant-inc/superpowers-evals

devnonymous 3mo ago

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?

sv123 3mo ago
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.
- shinycode 3mo ago
  Same here, the brainstorming and research phases are good and the spec part at well, I do side adversarial reviews all the time with other independent agents and feed sp the reviews and they are tools to avoid gliding over the surface. The dev process is longer but the result when done in a sound architecture with documented practices is quite good even though it’s slow. Very happy with the tool so far

losvedir 3mo ago

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.

mgambati 3mo ago
Ultracode is pretty good. I’m not basically using the grill-with-docs from Matt and default plan mode on Cc or codex. It’s just enough.
- ElijahLynn 3mo ago
  Did you mean "I'm basically" (!not)?
  - mgambati 3mo ago
    Yes! Crazy typo, sorry.
- hnhn34 3mo ago
  Is it usable on Pro plan? Seems like it would burn my rate limits immediately
bashtoni 3mo ago
Agreed. I often take a look at the skills and maybe take something from there to create a more minimal version that does just enough for my needs and nothing more. YAGNI is definitely the principle to be followed here. I'm sure all these people on Reddit that talk about having 5 Claude Max 20x plans and hitting the weekly limits on them all have a ton of these loaded.
Maxion 3mo ago
At least for me, writing the code // using the IDE // prompting the LLM to do the thing is not the hard part. The hard part is always understanding the actual problem // underlying assumptions // actual customer need and then architecturing the right solution to that. Actually implementing the solution is the easy part, and LLMs have made that now even easier. But they've not really helped interpret customer requirements when they give you logically inconsistent / unimplementable business processes that need major re-vamping before they can be coded. To some extent they can help de-code poorly worded emails sent by some exec while golfing or in a meeting. But they still can't conjure information out from nothing. Nor are they that good at helping to play the political game when you have team X and team Y depending new feature Z, but feature Z requires completely changing how either team does process Ab but neither will even admit that their processes aren't compatible with each other.

prplfsh 3mo ago

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.

mempko 3mo ago

This is great in concept but what prevents me from using it is TDD. I don't want to waste tokens on producing code that doesn't ship to the end user. Design by Contract is a far superior approach. If you've never heard of Design by Contract I don't blame you, our culture really failed to bring it mainstream. But I swear by it and it gives me real superpowers. Maybe I should fork this and gut the TDD part and replace it.

CharlesW 3mo ago
Nothing about Superpowers forces you to use TDD, brainstorm first, etc. It’s not rigid about the workflow.
deleted 3mo ago
[deleted]
simonw 3mo ago
What programming language are you using for Design by Contract?
- klibertp 3mo ago
  I'd like to know, too! DbC is an actual superpower. Coupled with a gradual type system, especially one that provides type refinements (not sure if that's a Racket-specific[1] or generic term), DbC covers a wide variety of problems and either eliminates them or makes debugging them a lot easier. The problem is that only two/three languages are built around DbC (Eiffel, Racket, Ada/SPARK). There are a few others (e.g., Clojure, Raku, Scala) that provide some degree of support, but their capabilities are incredibly basic compared to what, for example, Racket offers. And for mainstream programming languages, there are libraries, but it's a coin toss whether authors even understand the idea (I once asked in a ticket for some Python contract library about contracts for callables and was met with "what?" - as if specifying range constraints on ints was all DbC was about). Unfortunately, Racket is tiny, barely a blip in the training data. In theory, you could probably get agents to a new level of reliability by making them write Racket; in practice, though, you'll burn a lot more tokens on every single edit, because the agent will need to rediscover how to do things in Racket much more often than in Python. I had some hopes that LLMs and agents based on them would be an opportunity for less popular, but technically advanced languages. So far, it doesn't seem like it's happening; the ridiculous per-token API prices mean that you need a really good agent harness for your language - and what niche PL has resources to focus on building one? [1] https://docs.racket-lang.org/ts-reference/Experimental_Features.html#(part._.Logical_.Refinements_and_.Linear_.Integer_.Reasoning) https://docs.racket-lang.org/ts-reference/Experimental_Featu...

linsomniac 3mo ago

My use case is I have them installed and let Claude decide when to use them. Looks like for my recent sessions it has been using superpowers:test-driven-development 5%, and superpowers:subagent-driven... 1%. I haven't really been working on new projects this past week though which seems to be where they fire off the most, in particular the "writing a plan" one.

johnfn 3mo ago

To be blunt I can't take this product seriously when they don't even run benchmarks. Your prompts make Claude better? Cool: prove it. Methods to evaluate LLM performance exist, they're called evals/benchmarks, and every company that is serious about AI runs them when they release a new version. (Of course benchmarks have their own issues, but squabbling over which benchmark is best and what issues there are is step 2 in being a Serious AI Company and step 1 is running them at all!) The fact that the only proof they have that 6 is better than five is a hacky table in a screenshot from Fable is, honestly, concerning.

devnonymous 3mo ago
To be blunt you should perhaps read the README before being condescending and dismissive. https://github.com/prime-radiant-inc/superpowers-evals https://github.com/prime-radiant-inc/superpowers-evals
- johnfn 3mo ago
  You mean the obviously AI generated README? Did you even read it yourself?

mortsnort 3mo ago

Anyone have an opinion comparing this to GSD?

deleted 3mo ago
[deleted]

michelb 3mo ago

I’m a big fan of the Compound Engineering plugin from Every. As an amateur developer it helps me brainstorm, plan and implement apps very well. https://github.com/everyinc/compound-engineering-plugin https://github.com/everyinc/compound-engineering-plugin

ValentineC 3mo ago
I've been using Compound Engineering for the past few months too, but now that I'm seeing mention of how Superpowers consumes a lot of tokens and context, I wonder if Compound Engineering does the same. I often end my Claude Opus 1M sessions at around 60-80% context, and that's with doing `/context` once in a while, and forcing the agent to wrap up and write handover notes, so that I can start on a new unit with fresh context.

RomanPushkin 3mo ago

Superpowers is pretty much convincing LLMs they can do better. It almost never works that way.

deleted 3mo ago

[deleted]

Amekedl 3mo ago

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.

mcintyre1994 3mo ago

I think I’ve mostly found superpowers helpful, especially for TDD. It’s cool from this blog (and their GitHub) that they’ve verified it in various ways too. One issue is that I’ll sometimes see it wanting to write a whole doc for a follow on feature with a similar structure and have to tell it to just use the last one again. The most annoying thing is that it always pauses before implementing to ask if I want it to use Subagents (which it always recommends) or not.

lucrum 3mo ago
This is the point where I usually start a new session with a fresh context window and invoke the sub-agent development skill and just point to the spec+plan. I’d be curious to see if there was a way to automatically do this for me in Claude Code.

byzantinegene 3mo ago

seems like this would perform better with cheap open-source models on OpenCode compared to proprietary models like Claude Code or Codex.

tmach32 3mo ago

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: * 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. 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. 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.

NorthSouthNorth 3mo ago
I think you can write a quick script to toggle the disable-model-invocation to turn off auto invocation.

YuukiRey 3mo ago

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.

wejick 3mo ago

So far SDD (Spec Driven Development) with openspec hit the right balance for me, the Workflow is not too heavy while execution still churning good result given the spec is done well.

imgyuri 3mo ago

I feel like all these fat skills on top of agents will become stale very quickly. Unless it is for a very specific workflow with a need for deterministic outputs, I just don't see them having high value. If I do need such workflows I just use plan mode, and it is 90% sufficient. I created a skill that hooks on top of plan mode because of its shortcomings, but I'm pretty sure even this will become obsolete soon as models improve. https://github.com/oliver-im/jidoka https://github.com/oliver-im/jidoka

tomiow 3mo ago

[flagged]