What it actually does
Most agent failures are not model failures. They are process failures: the agent starts writing code before anyone has established what is being built or why.
Superpowers intervenes at exactly that moment. From the moment your agent sees you are building something, it steps back and asks questions instead of generating. Underneath is a set of composable skills plus the initial instructions that make sure the agent actually uses them, covering brainstorming, planning, and subagent-driven development across the software lifecycle.
Installation targets almost every client in the ecosystem — Claude Code, Antigravity, Codex App and CLI, Cursor, Factory Droid, Gemini CLI, GitHub Copilot CLI, Kimi Code, OpenCode, and Pi.
At roughly 270,000 stars it is the most-starred project in this catalog, which tells you how widely the underlying problem is felt.
Who it's for
- 01
Teams whose agents produce plausible code that solves the wrong problem
- 02
Engineering leads who want a consistent process applied regardless of who is driving
- 03
Anyone who has watched an agent confidently build something nobody asked for
- 04
Teams using several different agent clients who want one shared methodology
Where it earns its keep
- Forcing a requirements conversation before any code is generated
- Standardising how every engineer's agent approaches a new feature
- Breaking large work into subagent-driven pieces with clear boundaries
- Reducing rework caused by agents optimising for output volume over correctness
- Onboarding a new engineer into your team's process through their agent
Use it, or skip it
Reach for it when
- Rework, not throughput, is your bottleneck
- Different engineers get wildly different results from the same agent
- You are building something new where the requirements are genuinely unclear
- Your team spans multiple agent clients and consistency matters
Skip it when
- The task is small and well defined — the process overhead outweighs the benefit
- You want raw speed on a throwaway prototype
- Your team already has a strong, enforced process and the agent follows it
- You dislike opinionated tooling; this is a methodology with real opinions
10 automations
Ideas, not tutorials. Each one is work a team does by hand today.
- 01Engineering
Requirements gate before code
Every new feature request triggers a structured clarification pass, with the resulting brief posted to the ticket.
- 02Operations
Consistent onboarding process
New engineers inherit the team's methodology through their agent on day one rather than absorbing it over months.
- 03Engineering
Subagent work decomposition
Break a large epic into scoped subagent tasks automatically, each with its own acceptance criteria.
- 04Founders
Rework measurement
Track how much code gets reverted or rewritten before and after adopting the methodology.
- 05Founders
Brainstorm-to-spec pipeline
Turn a founder's loose idea into a structured spec through guided questioning, ready for estimation.
- 06Operations
Cross-client standardisation
Install the same skills across every agent client your team uses so output quality does not depend on tool choice.
- 07Engineering
Design review preparation
Have the agent produce the alternatives it considered and rejected, so design review starts from real options.
- 08Operations
Estimation grounding
Use the structured plan output to produce estimates based on decomposed work rather than a gut number.
- 09Operations
Scope-creep detection
Compare what shipped against the original brief and flag where scope expanded without a decision.
- 10Engineering
Post-mortem input
Because the reasoning is captured up front, feed it into retrospectives to see where the plan diverged from reality.
Want one of these running by Friday?
LimeDock builds these as real workflows inside your stack — deployed to your cloud, wired into your Slack and CRM, with the code in your repo. You pay a build fee and your own API keys, nothing else.
Source
Repository stats were read from the GitHub API and reflect the last time we refreshed this entry. The editorial breakdown above is LimeDock’s own analysis — we are not affiliated with obra.
https://github.com/obra/superpowers