Superpowers: Agentic Skills Framework for AI

Image: GitHub

Superpowers: Agentic Skills Framework for AI

Have you ever felt like the coding agent you're using is... underwhelming? You ask Claude Code or Codex to build a new feature, and instead of thinking it through, it just dives headfirst into writing code with no plan. The result? Bugs everywhere, a messy codebase, and you end up fixing everything from scratch.

That's exactly the problem Superpowers was built to solve. With 271K+ stars on GitHub, this framework has become a phenomenon in the AI coding world. Let's dig deeper into what Superpowers is, why it's so popular, and how it works.

What is Superpowers?

Superpowers is an agentic skills framework designed specifically for coding agents. In simpler terms, it gives AI coding agents "superpowers" — not just raw code generation, but the ability to work like a professional developer with a structured process.

Here are the quick facts:

• Stars: 271K+ on GitHub (an incredible number for a repo)
• Forks: 24K+
• Language: Shell (yes, it's primarily shell-script-based)
• License: MIT
• Author: Jesse Vincent of Prime Radiant
• GitHub: github.com/obra/superpowers

At its core, Superpowers is a complete software development methodology built on composable skill sets. These skills ensure your coding agent isn't just "smart" technically, but also follows a proper workflow.

Why Superpowers is Needed

Before Superpowers, coding agents typically worked in a rather... ad hoc way. You'd tell it to build something, and it would jump straight into coding. No brainstorming, no proper planning, no rigorous testing.

The problems:

• Lack of planning → AI writes code without a clear design
• No TDD → Code is written without tests, leading to hidden bugs
• Lack of structure → AI has no consistent workflow
• Hard to control → Developers struggle to guide the development direction

Superpowers addresses all of these with a systematic approach. The framework forces coding agents to think before acting, design before coding, and test before finishing.

Skills System: The Heart of Superpowers

What makes Superpowers unique is its skills system. Each skill is a specific set of instructions that governs how an agent handles a particular task. These skills are mandatory — not just suggestions, but required workflows that must be followed.

Complete Skills List

Superpowers provides 14 core skills organized into several categories:

🔬 Testing

• test-driven-development — Follows the RED-GREEN-REFACTOR cycle. You write a failing test first, confirm it fails (RED), write minimal code to make it pass (GREEN), then refactor. Superpowers will even delete code written before the test if you violate this rule!

🔍 Debugging

• systematic-debugging — A structured 4-phase debugging process: understand the problem, find the root cause, fix it, and verify. Includes root-cause-tracing and defense-in-depth techniques.
• verification-before-completion — Ensures a problem is truly resolved before marking it as done. No half-baked "fixes."

🤝 Collaboration

• brainstorming — A Socratic design approach where the agent asks questions to clarify your ideas before starting to code. The process saves a design document for reference.
• writing-plans — Creates extremely detailed implementation plans: every task includes the exact file path, complete code, and verification steps.
• executing-plans — Runs plans in batches with checkpoints for human review.
• dispatching-parallel-agents — Manages parallel subagent workflows to speed up the process.
• requesting-code-review — A pre-review checklist before code is submitted.
• receiving-code-review — How to respond to code review feedback.
• using-git-worktrees — Creates isolated branches for parallel development.
• finishing-a-development-branch — Decision workflow: merge, create PR, shelve, or discard.
• subagent-driven-development — Rapid iteration with two-stage review: spec compliance, then code quality.

🧩 Meta

• writing-skills — How to create new skills following best practices.
• using-superpowers — Introduction to the skills system as a whole.

How Skills Are Activated

What's cool about Superpowers is that skills activate automatically. You don't need special commands to turn on each skill. The agent will automatically check for relevant skills before working on any task.

For example:

• Starting a new project → brainstorming skill activates
• Design approved → using-git-worktrees skill activates
• Ready to code → writing-plans skill activates
• Coding begins → test-driven-development skill activates

These aren't just suggestions — they're mandatory workflows that must be followed.

How Superpowers Works

Let's walk through the complete Superpowers workflow from start to finish:

Step 1: Brainstorming

You start by saying something like "I want to build an authentication feature." But instead of coding immediately, the Superpowers agent will:

1. Ask questions to clarify requirements
2. Explore design alternatives
3. Present the design in small, reviewable pieces
4. Save a design document

This brainstorming process is like having a senior developer ask "what are you actually trying to build?" before writing any code.

Step 2: Set Up Git Worktree

Once the design is approved, the agent will:

1. Create an isolated new branch
2. Run project setup
3. Verify baseline tests pass cleanly

Step 3: Writing Plans

The implementation plan is created with extreme precision:

• Every task is broken down into 2–5 minutes of work
• Every task lists the exact file paths
• Implementation code is already included in the plan
• Every task has verification steps

Step 4: Subagent-Driven Development

This is the most exciting part. The main agent will:

1. Delegate each task to a new subagent
2. The subagent works on the task according to the plan
3. The main agent performs a two-stage review:
   • Specification compliance review (what was requested vs. what was built)
   • Code quality review (clean code, best practices)
4. If it passes review, move on to the next task

You can sit back for hours while the agent works autonomously without straying from the plan.

Step 5: Test-Driven Development

Throughout the implementation, the TDD skill is strictly enforced:

• RED: Write a failing test
• GREEN: Write minimal code to make the test pass
• REFACTOR: Improve the code without changing behavior

If you're caught writing code before writing tests, Superpowers will delete that code. Brutal, but effective!

Step 6: Code Review

Between tasks, the agent performs code review:

• Compares results against the plan
• Reports issues by severity
• Critical issues block progress until they're fixed

Step 7: Finishing the Branch

When all tasks are complete:

1. Verify all tests pass
2. Present options: merge, create PR, shelve, or discard
3. Clean up the worktree

Multi-Agent Support

One of Superpowers' key strengths is its broad multi-platform support. This framework isn't tied to a single coding agent — it's designed to work with many platforms at once.

Supported Platforms

At the time of writing, Superpowers supports 14+ coding agent platforms:

Why Multi-Agent Support Matters

In the fast-moving world of AI coding, developers aren't locked into a single platform. You might use Claude Code for one project, Codex for another, or Gemini CLI for quick tasks. With Superpowers, you can use the same workflow no matter where you are.

Each platform has its own plugin directory:

• .claude-plugin for Claude Code
• .codex-plugin for OpenCode
• .cursor-plugin for Cursor
• .devin-plugin for Devin CLI
• .hermes-plugin for Hermes Agent
• .kimi-plugin for Kimi Code
• .agents/plugins for other agent frameworks

Subagent-Driven Development

What truly makes Superpowers powerful is the concept of subagent-driven development. In this model:

1. The main agent acts as a "tech lead" orchestrating the workflow
2. Subagents are delegated to handle individual tasks
3. Each subagent works in isolation with limited context
4. The main agent reviews and evaluates the subagent's work

This mirrors how professional development teams work: the tech lead plans, developers execute, and the tech lead reviews.

Other Standout Features

Brainstorming Through Conversations

One of the newer features in v6.3.0 is conversational brainstorming. The agent doesn't just ask rigid questions — it truly engages in a dialogue to understand your needs. The resulting design document is presented in pieces that you can review one by one.

Git Worktrees

Superpowers uses git worktrees for parallel development. This means you can:

• Work on multiple features simultaneously
• Each feature has its own branch and working directory
• No need for stashing or constant branch switching

YAGNI and DRY

Superpowers enforces these principles:

• YAGNI (You Aren't Gonna Need It): Don't build features that haven't been requested
• DRY (Don't Repeat Yourself): Don't duplicate code
• Simplicity: Simplicity as the primary goal

Verification Before Completion

Before marking a task as done, the agent must verify:

• All tests pass
• Code matches specifications
• No regressions
• Code quality meets standards

Use Cases

1. Building a New Feature from Scratch

Scenario: You want to add an authentication system to a web application.

How Superpowers Helps:

1. Brainstorming: The agent asks about auth type (JWT, OAuth, session-based?), scope (login/logout/register?), and security requirements
2. Design document is created with clear architecture
3. Plan is broken into small tasks: user model, login endpoint, auth middleware, frontend integration
4. Subagents work on each task using TDD
5. Review and verification at every stage

Result: A well-tested, well-architected authentication feature, ready for production.

2. Refactoring a Large Codebase

Scenario: Your codebase has grown large and messy, and needs refactoring.

How Superpowers Helps:

1. Brainstorming: The agent helps identify areas that need refactoring
2. Plan is created incrementally — refactor section by section
3. Each refactor is backed by existing tests
4. Git worktrees allow refactoring on separate branches
5. Code review ensures refactoring doesn't change behavior

Result: A cleaner codebase without regression risk.

3. Contributing to Open Source

Scenario: You want to contribute to an open-source project.

How Superpowers Helps:

1. Brainstorming: The agent helps understand the project's codebase
2. Plan follows the project's contribution guidelines
3. TDD ensures your contribution is reliable
4. Code review before submitting the PR

Result: High-quality contributions ready for maintainer review.

4. Quick Prototyping

Scenario: You need a fast prototype to validate an idea.

How Superpowers Helps:

1. Light brainstorming for the prototype scope
2. Focused plan — core features only
3. Subagents work quickly
4. Prototype is done in short order

Result: A functional prototype ready for user testing.

5. Debugging a Production Issue

Scenario: There's a production bug that needs immediate fixing.

How Superpowers Helps:

1. systematic-debugging skill activates
2. Agent helps reproduce the bug
3. Root cause is analyzed using the 4-phase method
4. Fix is tested with TDD before being applied
5. verification-before-completion ensures the fix actually works

Result: Bug is properly fixed and verified.

Philosophy

Superpowers is built on a strong philosophy:

1. Test-Driven Development: Always write tests, no exceptions
2. Systematic over Ad-hoc: Process beats guessing
3. Complexity Reduction: Simplicity as the primary goal
4. Evidence over Claims: Verify before declaring done

This philosophy isn't just lip service — it's directly implemented into every skill.

Pros and Cons

Pros

• ✅ Highly structured workflow
• ✅ Broad multi-platform support
• ✅ Strictly enforced TDD
• ✅ Subagent-driven development speeds up the process
• ✅ Automatic — no special commands needed
• ✅ Open source with MIT license
• ✅ Active community (271K+ stars!)

Cons

• ⚠️ Learning curve to understand all skills
• ⚠️ May feel slow for very simple tasks
• ⚠️ Requires a coding agent that supports subagents
• ⚠️ Workspace must be configured correctly for multi-platform use

Getting Started

Install for Claude Code

/plugin install superpowers@claude-plugins-official

Install for Hermes Agent

hermes plugins install obra/superpowers --enable

Install for Gemini CLI

gemini extensions install https://github.com/obra/superpowers

Install for Codex CLI

/plugins
# Search for "superpowers" and select Install Plugin

After installation, restart your agent. Start coding as usual — Superpowers will activate automatically.

Community

Superpowers has an active and supportive community:

• Discord: discord.gg/35wsABTejz for support, questions, and sharing
• GitHub Issues: github.com/obra/superpowers/issues for bug reports and feature requests
• Release Announcements: primeradiant.com/superpowers for version notifications

Conclusion

Superpowers isn't just a collection of prompts or tips — it's a comprehensive software development methodology framework for coding agents. With 14+ structured skills, multi-platform support, and strict TDD philosophy, Superpowers transforms how coding agents work.

If you're serious about using coding agents for project development, Superpowers is a must-try. This framework proves that AI coding agents don't have to work ad-hoc — they can follow a structured, measurable, and reliable process.

With 271K+ stars on GitHub and a growing community, Superpowers has already proven its value to thousands of developers worldwide. It's time your coding agent had some superpowers.

Repository Info:

• GitHub: github.com/obra/superpowers
• Stars: 271K+
• License: MIT
• Author: Jesse Vincent / Prime Radiant
• Latest Version: v6.3.0