Superpowers: The Agentic Skills Framework That Turns AI Coding Agents Into Autonomous Software Engineers

What Is Superpowers and Why It Matters

In the rapidly evolving landscape of AI-assisted software development, tools like GitHub Copilot and Claude Code have revolutionized how we write code. But there's a gap between writing code and engineering software. That's where Superpowers comes in.

Superpowers isn't just another code completion tool or prompt library. It's a complete software development methodology for AI coding agents, built on a foundation of composable skills that transform your agent from a code generator into an autonomous software engineer.

Created by Jesse Vincent and the team at Prime Radiant, Superpowers has quickly gained traction in the developer community. Unlike other tools that require manual prompting or configuration, Superpowers works automatically—your agent just has superpowers from the moment you start building.

How Superpowers Works: The Automatic Workflow

The brilliance of Superpowers lies in its automatic workflow. Here's what happens when you start a new project with Superpowers enabled:

1. Brainstorming and Design

When you describe what you're building, your agent doesn't immediately jump into writing code. Instead, it activates the brainstorming skill, which:

• Asks clarifying questions to understand your real goals
• Explores alternative approaches and trade-offs
• Generates a design document in digestible chunks
• Waits for your approval before proceeding

This Socratic approach ensures that the agent truly understands what you're trying to build, not just what you said in your initial prompt.

2. Implementation Planning

Once you approve the design, the writing-plans skill activates. Your agent creates a detailed implementation plan that's:

• Broken into bite-sized tasks (2-5 minutes each)
• Specific enough for "an enthusiastic junior engineer with poor taste, no judgment, no project context, and an aversion to testing" to follow
• Complete with exact file paths, code snippets, and verification steps

This level of detail is crucial—it transforms vague requirements into executable tasks.

3. Subagent-Driven Development

Here's where Superpowers truly shines. The subagent-driven-development skill launches a process where:

• A fresh subagent is dispatched for each task
• Each subagent works independently with full context
• Two-stage review happens automatically (spec compliance, then code quality)
• The main agent orchestrates the entire process

It's not uncommon for agents with Superpowers to work autonomously for hours at a time, staying true to the plan you approved.

Core Skills That Make Superpowers Work

Superpowers is built on a foundation of specialized skills. Here are the most important ones:

Test-Driven Development (TDD)

The test-driven-development skill enforces strict RED-GREEN-REFACTOR methodology:

1. RED: Write a failing test first
2. GREEN: Write minimal code to make the test pass
3. REFACTOR: Improve code while keeping tests green

If code is written before tests, the skill deletes it and starts over. This ensures high-quality, testable code every time.

Systematic Debugging

The systematic-debugging skill replaces guesswork with a 4-phase process:

• Phase 1: Reproduce the issue reliably
• Phase 2: Isolate the root cause
• Phase 3: Implement a fix
• Phase 4: Verify the fix and add regression tests

No more "let's try this and see if it works" debugging.

Code Review

The requesting-code-review skill provides automated code review between tasks:

• Reviews code against the original plan
• Reports issues by severity (critical, warning, info)
• Critical issues block progress until resolved
• Ensures consistency across the entire codebase

Real-World Example: Building a REST API

Let's see Superpowers in action with a practical example. Say you want to build a REST API for a todo application.

Step 1: You describe the project

I want to build a REST API for a todo app with user authentication, CRUD operations for todos, and PostgreSQL database.

Step 2: Agent brainstorms

Your agent asks clarifying questions:

• What authentication method? (JWT, OAuth, session-based?)
• Should todos have categories or tags?
• Do you need pagination for listing todos?
• What's your deployment target?

Step 3: Design document

After the conversation, your agent presents a design document covering:

• Technology stack (Express.js, PostgreSQL, JWT)
• Database schema
• API endpoints
• Authentication flow
• Error handling strategy

Step 4: Implementation plan

Your agent creates tasks like:

1. Set up project structure and dependencies
2. Create database schema and migrations
3. Implement user registration endpoint
4. Implement user login endpoint
5. Add JWT middleware
6. Implement CRUD operations for todos
7. Add input validation and error handling
8. Write integration tests

Step 5: Autonomous execution

You say "go," and your agent:

• Creates a git worktree for isolated development
• Dispatches subagents for each task
• Enforces TDD throughout
• Conducts code reviews between tasks
• Commits clean, working code

Two hours later, you have a fully functional, tested, and reviewed REST API.

Key Benefits of Using Superpowers

• Autonomous Development: Agents work independently for hours while staying true to your vision
• Consistent Quality: Enforced TDD, code reviews, and systematic debugging ensure high-quality code
• Cross-Platform: Works with Claude Code, Cursor, Codex CLI, GitHub Copilot, Kimi Code, OpenCode, and more
• Composable Skills: Use only the skills you need, or let the system decide automatically
• Open Source: MIT licensed, community-driven development
• Enterprise Ready: Commercial support available from Prime Radiant

Installation and Setup

Installing Superpowers is straightforward and depends on your coding agent:

Claude Code

# Via official marketplace
/plugin install superpowers@claude-plugins-official

# Or via Superpowers marketplace
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

Cursor

# In Cursor Agent chat
/add-plugin superpowers

Codex CLI

/plugins
# Search for "superpowers" and install

OpenCode

Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.opencode/INSTALL.md

After installation, Superpowers activates automatically. No configuration needed.

FAQ

1. Is Superpowers free to use?

Yes, Superpowers is open-source under the MIT license. You can use it freely for personal and commercial projects. Commercial support is available from Prime Radiant for enterprise users.

2. Which coding agents does Superpowers support?

Superpowers works with Claude Code, Cursor, Codex CLI, Codex App, GitHub Copilot CLI, Kimi Code, OpenCode, Pi, Antigravity, and Factory Droid. Each agent has its own installation method.

3. Do I need to configure anything after installation?

No. Superpowers activates automatically when you start building. The skills trigger based on context, so you don't need to manually invoke them.

4. Can I use only specific skills instead of the full workflow?

Yes. While the full workflow is automatic, you can also use individual skills like test-driven-development or systematic-debugging independently.

5. Does Superpowers work with existing projects?

Absolutely. Superpowers works with both new and existing projects. It adapts to your project structure and coding style.

6. How does Superpowers handle complex, multi-file changes?

Superpowers uses git worktrees to create isolated workspaces for each task. This allows for parallel development and easy rollback if needed.

7. What if the agent makes a mistake?

The two-stage code review process catches most issues. Critical problems block progress until resolved. You can also intervene at any checkpoint in the workflow.

8. Does Superpowers collect any data?

By default, Superpowers loads a logo from Prime Radiant's website for basic usage telemetry. This is optional and can be disabled by setting SUPERPOWERS_DISABLE_TELEMETRY=true. No project details, prompts, or code are collected.

9. Can I contribute new skills to Superpowers?

Contributions are welcome, but new skills must work across all supported coding agents. Check the writing-skills skill for guidelines on creating new skills.

10. How is Superpowers different from other AI coding tools?

Unlike code completion tools, Superpowers is a complete development methodology. It handles the entire software engineering lifecycle—from design to deployment—not just code generation.