In the previous post on Claude Code agents, the recurring theme was delegation: subagents, isolated context windows, worktrees, chaining work between specialists. Those are the raw materials. Superpowers is what happens when someone assembles them into an opinionated process and refuses to let Claude skip steps.
The problem it targets is one anyone who’s paired with an AI on a non-trivial feature has felt. As the plugin’s own framing puts it: “Claude with no workflow races ahead on your first vague description, builds confidently in the wrong direction, and leaves you three hours deep in a teardown.” The model is eager. Eagerness without a plan is how you end up reviewing 600 lines of code that solve the wrong problem.
Superpowers is an open-source plugin (built by Jesse Vincent, known as “obra”, and Prime Radiant, MIT-licensed) that fixes this not by making Claude smarter but by making it disciplined. It ships a framework of composable skills that guide the agent through a structured development process, and the skills activate automatically once installed.
It’s a one-liner through the official plugin marketplace:
/plugin install superpowers@claude-plugins-officialOr via the project’s own marketplace, if you want updates straight from the source:
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplaceAfter that you don’t invoke anything special. You describe what you want to build, and the relevant skills trigger themselves based on where you are in the process.
Underneath the marketing, the plugin is “markdown files with instructions, checklists, and process diagrams”. It’s the same Skills mechanism Claude Code already supports, just curated into a coherent sequence. The sequence is the whole point. Roughly:
isolation: worktree idea from the agents post, promoted to a default.)The checkboxes in the plan double as recovery points: if a session dies halfway, the next one knows exactly what’s done and what’s left.
The plugin is a library, not a monolith. Beyond the core flow, you get focused skills you can lean on individually:
test-driven-development, systematic-debugging, verification-before-completionbrainstorming, writing-plans, executing-plans, dispatching-parallel-agents, requesting-code-review, using-git-worktreeswriting-skills (so the agent can author new skills) and using-superpowers (the system’s own onboarding)That writing-skills skill is the quietly interesting one: the framework is designed to grow. When you hit a workflow it doesn’t cover, you can have it codify a new skill rather than re-explaining yourself next time. It’s the same “convert repeated instructions into reusable blocks” idea, applied recursively.
The Builder.io write-up gives a concrete example. For Ding, a Go-based alerting daemon, the brainstorm phase produced a 424-line specification document that resolved genuinely tricky decisions (per-label-set cooldowns, hot-reload semantics) before a single line of code was written. That’s the entire value proposition in miniature: the expensive thinking happens up front, on paper, where changing your mind is cheap.
Reported upsides from teams using it:
Structure has a cost, and the plugin is honest about its edges:
Superpowers isn’t magic, and it isn’t a new capability. It’s a forcing function. Everything it does, you could do by hand with subagents, worktrees, and careful prompting. What it actually provides is the refusal to skip the boring parts: write the spec, get it approved, write the tests, then write the code. The agents post was about the building blocks; this is one well-reasoned answer to the question of how to assemble them so the eager model in the loop stops racing ahead and starts building the thing you actually asked for.
If you’ve already internalized the subagent patterns, treat Superpowers as a reference implementation worth reading even if you don’t adopt it wholesale. The skills are just markdown, and they’re a master class in turning good intentions into a process Claude can’t quietly ignore.