Superpowers - AI Agent Skills Framework

Look, I get it. You’ve tried using AI coding assistants. You’ve asked Claude Code to “build me a login page.” And what did you get?

A half-baked React component with no tests, hardcoded credentials, and enough security vulnerabilities to make a hacker weep with joy. 😭

Here’s the thing: AI coding assistants are like junior developers on crack. They write code fast, but they have NO IDEA what they’re doing. They don’t write tests. They don’t do code review. They don’t follow TDD. They just
 vibe code. And then YOU have to clean up the mess.

Well, guess what? There’s a solution. And it’s called Superpowers. đŸ’Ș

đŸ”„ Why Is Superpowers Breaking the Internet?

Let me drop some numbers on you:

  • 🌟 208,000+ GitHub stars (HOLY SHIT! That’s almost 210k!)
  • đŸ€– Complete software development methodology for AI agents (not just a “tool”)
  • 📩 1000+ agentic skills (largest collection on GitHub!)
  • 🔌 Works with EVERYTHING: Claude Code, Codex, Cursor, GitHub Copilot CLI, Gemini CLI, OpenCode, Factory Droid
  • 🔒 Forces TDD, Code Review, Git Worktrees, Sub-agent collaboration (no more “vibe coding”)
  • 🚀 v5.1.0 (released May 4, 2026—BRAND NEW!)
  • 💡 Makes your AI code like a SENIOR ENGINEER (not a junior who writes shit code)

Translation: Superpowers is like giving your AI coding assistant a PhD in Software Engineering + 10 years of senior dev experience + a conscience that actually gives a fuck about code quality. 🎓

đŸ› ïž How to Install Superpowers (Pick Your Flavor)

The beautiful thing about Superpowers is that it works with ALMOST EVERY AI CODING TOOL. Here’s how to install it:

Option 1: Claude Code (for the “I’m a Claude fanboy” crowd)

1
2
3
4
5
6
# Method 1: Official marketplace
/plugin install superpowers@claude-plugins-official

# Method 2: Custom marketplace (if you want the latest updates)
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

Boom. Your Claude Code now has SUPERPOWERS. đŸ’Ș

Option 2: Cursor (for the “I like my IDE to have AI” crowd)

  1. Open Cursor
  2. In the Agent chat box, type: /add-plugin superpowers
  3. Or go to the Plugin Marketplace and search “superpowers”
  4. Click install
  5. Watch your AI transform from “junior dev” to “10x senior architect”

Option 3: Codex CLI (for the “I use OpenAI’s tools” crowd)

1
2
3
# In Codex CLI
/plugins
# Search for "superpowers" and click install

Or if you’re using the Codex App:

  1. Click “Plugins” in the sidebar
  2. Go to Coding category
  3. Find Superpowers
  4. Click the “+” button
  5. Follow the prompts

Option 4: GitHub Copilot CLI (for the “I use Microsoft’s tools” crowd)

1
2
copilot plugin marketplace add obra/superpowers-marketplace
copilot plugin install superpowers@superpowers-marketplace

Option 5: Gemini CLI (for the “I use Google’s tools” crowd)

1
2
3
gemini extensions install https://github.com/obra/superpowers
# To update later:
gemini extensions update superpowers

Option 6: OpenCode (for the “I use open-source everything” crowd)

1
2
3
# Fetch the install guide
curl -fsSL https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.opencode/INSTALL.md
# Follow the instructions (or read docs/README.opencode.md)

Option 7: Factory Droid (for the “I’m a robot” crowd)

1
2
droid plugin marketplace add https://github.com/obra/superpowers
droid plugin install superpowers@superpowers

Translation: No matter what AI coding tool you use, Superpowers has your back. It’s like the universal adapter for AI coding excellence. 🔌

💡 What Does Superpowers Actually DO? (a.k.a. “Why Your AI Stops Writing Shit Code”)

Alright, let’s talk specifics. What does Superpowers actually DO?

Answer: It forces your AI to follow software engineering best practices. No more “vibe coding.” No more “I’ll write tests later.” No more “let’s just ship it and see what happens.” (Spoiler: what happens is production catches fire. đŸ”„)

The 7-Step Core Workflow (Forced, Not Optional)

Superpowers has a 7-step core workflow that your AI MUST follow (it’s not optional—the skills are forced before each task):

Step 1: Brainstorming (a.k.a. “Don’t Write Code Before You Know What You’re Building”)

Problem: You ask your AI to “build me a login page,” and it immediately starts writing React components.

Solution: Superpowers forces your AI to:

  1. Ask YOU questions to clarify requirements
  2. Show you a design document (in chunks, so you don’t fall asleep)
  3. Get YOUR approval before writing a single line of code

Result: Your AI actually builds what you WANT, not what it THINKS you want. 🎯

Step 2: Git Worktrees (a.k.a. “Don’t Mess Up Your Main Branch”)

Problem: Your AI creates a new branch, but then it accidentally commits broken code to main.

Solution: Superpowers forces your AI to:

  1. Create a separate Git worktree for each feature
  2. Verify that tests pass on the main branch
  3. Only THEN start writing code

Result: Your main branch stays clean. Your AI can’t break production. Everyone wins. 🍀

Step 3: Writing Plans (a.k.a. “Don’t Wing It”)

Problem: Your AI writes code without a plan. It’s like a contractor building a house without blueprints. (Spoiler: the house collapses.)

Solution: Superpowers forces your AI to:

  1. Break down the work into 2-5 minute tasks
  2. For each task, write:
    • Which files to modify
    • The ACTUAL code to write
    • How to verify it works (tests!)

Result: Your AI has a PLAN. It doesn’t “wing it.” It’s like having a senior architect who actually gives a shit. 📐

Step 4: Sub-agent Driven Development (a.k.a. “Divide and Conquer”)

Problem: Your AI tries to do everything itself. It’s slow. It gets confused. It forgets what it was doing.

Solution: Superpowers lets your AI spawn sub-agents (mini-AIs) to handle individual tasks. Each sub-agent:

  1. Takes one task from the plan
  2. Implements it
  3. Runs tests
  4. Reports back

And then Superpowers does a two-stage review:

  • Stage 1: Does this actually meet the requirements?
  • Stage 2: Is the code quality any good? (Or did the sub-agent write spaghetti code?)

Result: Your AI works 10x faster by delegating tasks. It’s like having a team of junior devs who actually listen to their tech lead. đŸ‘„

Step 5: Test-Driven Development (a.k.a. “Write Tests FIRST, You Animal”)

Problem: Your AI writes code without tests. Then you find out it’s broken. Then you cry.

Solution: Superpowers forces your AI to follow TDD:

  1. Write a FAILING test first (red)
  2. Verify the test FAILS (if it passes, your test is wrong)
  3. Write the MINIMAL code to make the test pass (green)
  4. Verify the test PASSES
  5. Refactor (clean up the code)
  6. Commit
  7. DELETE any code that was written before the test (because that code is SHIT)

Result: Your code has 100% test coverage. Your AI can’t “forget” to write tests. It’s forced to. đŸ§Ș

Step 6: Code Review (a.k.a. “Don’t Merge Shit Code”)

Problem: Your AI writes code, then immediately commits it. No review. No quality check. Just
 hope.

Solution: Superpowers forces your AI to:

  1. Trigger a code review when switching tasks
  2. Report issues by severity (critical, major, minor)
  3. BLOCK development if there are critical issues

Result: Your code gets reviewed BEFORE it’s merged. It’s like having a senior dev who actually catches your mistakes. 👀

Step 7: Finishing a Development Branch (a.k.a. “Clean Up After Yourself”)

Problem: Your AI finishes a feature, but leaves a mess. Uncommitted changes. Broken tests. Dangling worktrees.

Solution: Superpowers forces your AI to:

  1. Verify ALL tests pass
  2. Give YOU options: merge, create PR, keep branch, or discard
  3. Automatically clean up the worktree

Result: Your repo stays clean. Your AI doesn’t leave a mess. You don’t have to clean up after it. đŸ§č

đŸ„Š Superpowers vs. The World (Spoiler: Superpowers Wins)

Feature Superpowers “Vibe Coding” (no framework) Manual TDD/Code Review
Forces TDD ✅ YES (automatic) ❌ NO (AI “forgets”) ⚠ You have to remember
Forces Code Review ✅ YES (automatic) ❌ NO ⚠ You have to remember
Sub-agent Collaboration ✅ YES (built-in) ❌ NO ❌ NO (you’re alone)
Git Worktree Management ✅ YES (automatic) ❌ NO ⚠ You have to remember
Brainstorming (Requirements Clarification) ✅ YES (forced) ❌ NO (AI guesses) ⚠ You have to do it
Works with Claude Code ✅ YES ✅ YES ✅ YES
Works with Cursor ✅ YES ✅ YES ✅ YES
Works with Codex ✅ YES ✅ YES ✅ YES
Learning Curve ⚠ Moderate (but worth it) ✅ Easy (but you get shit code) ⚠ Moderate
Vibe đŸ’Ș “I’m a 10x dev” đŸ€Ą “I’m a clown” 😓 “I’m exhausted”

The verdict: If you’re serious about code quality, Superpowers is the only choice. If you like “vibe coding” and then spending 3 hours debugging production, go ahead and skip it. I’ll be over here, actually shipping working code. 😎

🚀 Hands-On Project: Build a Login Page (the RIGHT Way)

Alright, enough talk. Let’s build something USEFUL (and see how Superpowers changes the game).

We’re gonna build a Login Page with:

  • ✅ React + TypeScript
  • ✅ TDD (tests FIRST!)
  • ✅ Form validation
  • ✅ API integration
  • ✅ Code review before merge

Step 1: Install Superpowers (Duh)

Follow the installation steps above for your AI tool of choice. (If you don’t have Superpowers installed, the rest of this tutorial is useless. 😏)

Step 2: Start a New Project

1
2
npx create-react-app login-page --template typescript
cd login-page

Step 3: Ask Your AI to Build a Login Page (the Superpowers Way)

YOU: “Build me a login page with email/password validation and API integration.”

Without Superpowers: Your AI immediately writes a Login.tsx component with no tests, hardcoded API endpoints, and any types everywhere. 💀

With Superpowers: Your AI responds:

1
2
3
4
5
6
7
8
9
đŸ€–: Before I start, I have some questions:
1. What validation rules do you want for email/password?
2. Which API endpoint should I call for login?
3. Should I use a library like Formik or React Hook Form?
4. Do you want error handling (toast notifications)?
5. Should I use Context API or Redux for state management?

Also, I'm going to follow TDD. I'll write tests first, then implement.
Is that okay?

YOU: “Yes, use React Hook Form, Zod for validation, and show toast notifications on error. API endpoint is POST /api/login.”

AI: “Got it! Let me create a plan
”

(Your AI then writes a plan with 2-5 minute tasks, each with file paths, code, and verification steps.)

Step 4: Watch the Magic Happen

With Superpowers, your AI will:

  1. Create a Git worktree (so it doesn’t mess up main)
  2. Write a FAILING test (red)
  3. Verify the test FAILS (if it passes, the test is wrong)
  4. Write MINIMAL code to make the test pass (green)
  5. Refactor (clean up)
  6. Commit
  7. Spawn a sub-agent to handle the next task
  8. Do a code review before merging

Result: You get a FULLY TESTED, PRODUCTION-READY login page. Not a half-baked component that breaks when you look at it funny. 🎉

Step 5: Merge and Clean Up

After all tasks are done, your AI will:

  1. Verify ALL tests pass
  2. Ask YOU: “Merge to main? Create a PR? Keep the branch? Discard?”
  3. Clean up the worktree

Result: Your main branch is clean. Your code is tested. You didn’t have to do anything. 😎

đŸ§± Technical Deep Dive (for the Nerds đŸ€“)

Alright, let’s talk tech stack. Because if you’re gonna use a framework, you should know what’s under the hood.

What’s Superpowers Built With?

  • Skills: Markdown files (.md) with YAML frontmatter
  • Installation: Each AI tool has its own plugin system (Claude Code plugins, Cursor plugins, etc.)
  • Methodology: TDD + Sub-agent collaboration + Git worktrees + Code review
  • Philosophy: “Forced skills” (not optional—the AI MUST follow them)

How Does Superpowers Force Skills?

Each skill is a Markdown file with:

  • Trigger conditions (when should this skill activate?)
  • Instructions (what should the AI do?)
  • Examples (how to do it right)

Example skill structure:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
---
name: test-driven-development
description: Force TDD (red-green-refactor)
trigger:
  - before: write-code
  - before: implement-feature
---

# Test-Driven Development

You MUST follow TDD:
1. Write a FAILING test first (red)
2. Verify the test FAILS
3. Write MINIMAL code to make the test pass (green)
4. Verify the test PASSES
5. Refactor
6. Commit
7. DELETE any code written before the test

Translation: Superpowers is like a CONSTITUTION for your AI. It can’t break the rules, because the rules are FORCED. 📜

Can I Write Custom Skills?

HELL YES. Superpowers is open-source, which means you can:

  1. Write custom skills in Markdown
  2. Share them with the community
  3. Contribute to the official repo
  4. Profit (if people actually use them)

Example custom skill:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
---
name: dont-use-any-types
description: Ban the `any` type in TypeScript
trigger:
  - before: write-typescript
---

# No `any` Types Allowed

You MUST NOT use the `any` type.
Use `unknown` or proper types instead.

Bad:
```typescript
function handleData(data: any) { ... }

Good:

1
2
3
4
function handleData(data: unknown) { 
  const parsed = parseData(data);
  ...
}

**Translation**: Superpowers is as flexible as a yoga instructor who's had one too many espressos. ☕

---

## 📚 Resources (a.k.a. "Don't Tell Me You Got Stuck and Didn't Read the Docs")

1. **Official GitHub Repository**: [github.com/obra/superpowers](https://github.com/obra/superpowers) — star it, fork it, contribute to it! ⭐
2. **Official Documentation**: [superpowers.dev](https://superpowers.dev/) (if they have a site) — read it!
3. **Community Forum**: Check the GitHub Discussions tab — ask questions, get judged (kindly)
4. **YouTube Tutorials**: Search "Superpowers Claude Code tutorial" and prepare to fall down a rabbit hole
5. **Skills Directory**: Check the `skills/` folder in the repo — see what skills are available!

---

## 🎬 Final Thoughts (a.k.a. "Why You Should Star This Repo on GitHub")

Look, I'm not gonna lie to you: **Superpowers is a game-changer**. 

If you're still "vibe coding" without TDD, without code review, without a plan... **you're doing it wrong**. If you're letting your AI write shit code and then spending 3 hours debugging production... **you're wasting your life**. 

So here's my challenge to you:

1. **Go star Superpowers on GitHub** ([github.com/obra/superpowers](https://github.com/obra/superpowers)) — show some love to the open-source community! ⭐
2. **Install it this week** — even if you're just trying it out
3. **Build one feature with TDD** — and see the difference
4. **Share your custom skills with the community** — because we all benefit when we share knowledge
5. **Profit** — literally, ship better code faster đŸ€‘

And remember: **The best code is the code that's TESTED.** (Or at least, the code that doesn't break production. 😉)

---

## 📝 TL;DR (for the Impatient)

- 🌟 **Superpowers has 208,000+ GitHub stars** — join the party!
- đŸ€– **Complete software development methodology for AI agents** — not just a "tool"
- 📩 **1000+ agentic skills** — largest collection on GitHub!
- 🔌 **Works with EVERYTHING** — Claude Code, Cursor, Codex, Copilot, Gemini, OpenCode, Factory Droid
- 🔒 **Forces TDD, Code Review, Git Worktrees, Sub-agent collaboration** — no more "vibe coding"
- 🚀 **v5.1.0** (released May 4, 2026)
- 💡 **Makes your AI code like a SENIOR ENGINEER** — not a junior who writes shit code

**Bottom line**: If you're serious about code quality and you use AI coding assistants, **Superpowers is mandatory**. It's like a seatbelt for your AI. You might think you don't need it, until you crash. Then you'll wish you had it. đŸ’ș

Now go forth and build some OVERPOWERED AI-assisted software! đŸ’Ș🚀

---

**P.S.** If you enjoyed this article, **smash that star button on GitHub**! ⭐ And if you didn't... well, Superpowers is open-source, so you can fork it and make it better. Or not. I'm not your boss. 😎

**P.P.S.** If you're still reading this, you either really like my writing or you're procrastinating on actual work. Either way, I'm not judging. 😏

**P.P.P.S.** Seriously, go check out Superpowers. It'll change your AI coding game. Or at least, it'll stop your AI from writing shit code. And isn't that what we all want? đŸ€·â€â™‚ïž