If you've used Claude Code or Codex to write code, you've probably run into this problem:
You give a vague requirement, and the Agent enthusiastically starts coding—producing a bunch of code that's completely off track. You correct it, and it starts over from scratch. Try again, and it goes off track once more.
Superpowers, created by obra, aims to solve exactly this problem.
98,200 stars. This is the highest-starred project on GitHub Trending this week. But it's not a coding framework, not a new programming tool, and not an AI model. It's a methodology—a methodology that teaches AI coding agents "how to do software development correctly."
What It Does
The core logic of Superpowers is actually quite simple, yet highly effective:
Step 1: brainstorming
The Agent doesn't jump straight into writing code. Instead, it takes a step back and asks you: "What exactly are you trying to build?" Through a few rounds of conversation, it turns a vague requirement into a clear specification document. It then breaks the spec into chunks for you to review and confirm section by section.
This step solves the "wrong direction" problem. Most AI coding failures aren't due to an inability to write code, but because the goal wasn't clearly defined from the start.
Step 2: using-git-worktrees
Once the spec is confirmed, the Agent creates an isolated workspace—a new branch, a clean environment, and runs tests to establish a baseline. This ensures the development process doesn't pollute the main branch.
Step 3: writing-plans
This is the most practical part of Superpowers. It breaks down the entire development work into small tasks that can be completed in 2-5 minutes. Each task includes precise file paths, complete code snippets, and verification steps. Instead of vague descriptions like "optimize performance," it specifies "add caching logic at line 42 in src/utils.ts, and run npm test -- cache to verify it passes."
Step 4: subagent-driven-development
The Agent doesn't just dump all the code at once. It delegates tasks to sub-agents, with each sub-agent handling a specific engineering task. Once completed, the main Agent checks and reviews the work before moving on to the next task.
The author, Jesse, notes that with this workflow, Claude can often work autonomously for hours without deviating from the plan.
Why It Works
I believe Superpowers works not because of any cutting-edge technology. On the contrary, its core philosophy is almost directly borrowed from classic software engineering:
- Design first, code later—Not a new concept, but AI Agents don't do this by default.
- Small, fast iterations—Task granularity at the 2-5 minute level, each with clear verification criteria.
- Red/Green TDD—Write failing tests first, then write code to make them pass.
- YAGNI and DRY—Only build what's needed, and avoid repetition.
Superpowers' innovation lies in: encoding these classic principles into the Agent's behavioral patterns. You don't need to manually guide it; the Agent automatically triggers these skills.
Compatibility
This is one area where Superpowers shines. It doesn't just support Claude Code; it's compatible with almost all mainstream coding Agents:
- Claude Code (available on the official plugin marketplace)
- OpenAI Codex CLI and Codex App
- Factory Droid
- Gemini CLI
- OpenCode
- Cursor
- GitHub Copilot CLI
Each platform has its own installation method, but the core methodology remains the same.
A Practical Comparison
Workflow without Superpowers: You say "Help me add a user login feature" → Agent starts coding → Writes JWT auth but forgets password hashing → You catch it and ask for a fix → It fixes half of it and starts writing database migrations → You're forced to manually control every step.
Workflow with Superpowers: You say "Help me add a user login feature" → Agent first asks "What authentication method do you need?" → Spec confirmed → Generates a plan: Task 1 (Password Hashing), Task 2 (JWT Token), Task 3 (Database Migration)... → Sub-agents execute them one by one → You only need to review at key milestones.
This difference might not be obvious in small projects, but in medium-to-large scale projects, the gap widens significantly.
Target Audience
Ideal for:
- Developers with some experience who want to use AI Agents to accelerate their workflow.
- Developers who need AI Agents to handle complex projects (multi-module, multi-file).
- Those who want to reduce manual guidance and let Agents work more autonomously.
Less suitable for:
- Complete beginners who just want AI to generate code with one click (Superpowers requires you to review specs and plans).
- Scenarios that only require writing a few simple scripts (overkill for such tasks).
Controversy
Some might argue: Isn't this just a collection of CLAUDE.md files? What's the big deal?
This criticism has some merit. Superpowers indeed doesn't introduce any technological breakthroughs. But what it does is often underestimated: translating software engineering best practices into a set of instructions that AI Agents can understand and execute automatically. This isn't as simple as writing a few prompts; it requires a deep understanding of these practices and a precise grasp of Agent behavioral patterns.
The 98,000 stars show that the community recognizes the value of this direction.
Conclusion
Superpowers represents an important trend: AI coding tools are evolving from "code generators" to "engineering collaboration partners."
When Agents not only write code but also conduct requirement analysis, draft design documents, break down tasks, and self-review—they are no longer simple chatbots. Instead, they become more like a reliable junior engineer on your team.
This is a direction worth tracking closely.