Superpowers: The Agentic Skills Framework That Turns Your AI Coding Agent Into a Senior Engineer — Here's How It Works

Why Your AI Coding Agent Needs a Development Methodology

You've probably noticed a pattern with AI coding assistants: they jump straight into writing code the moment you describe what you want. No planning. No design review. No test strategy. Just code.

This works fine for simple tasks—rename a variable, add a utility function, write a unit test. But for anything more complex, you end up with a tangled mess that needs refactoring, debugging, and often rewriting from scratch.

The problem isn't that AI can't write good code. The problem is that writing code is only 20% of software development. The other 80% is planning, testing, debugging, reviewing, and iterating.

Superpowers solves this by giving your AI agent a complete software development methodology built from composable skills that trigger automatically. It doesn't just generate code—it engineers software.

What Superpowers Actually Does

Superpowers is a framework of 15+ skills that work together to enforce best practices throughout the development lifecycle. Here's how it transforms your AI agent's workflow:

When you start building something, Superpowers activates its brainstorming skill. Instead of immediately writing code, the agent asks clarifying questions, explores alternatives, and refines your rough idea into a proper design document. It presents the design in digestible chunks so you can actually review and approve it.

Once you sign off on the design, the writing-plans skill kicks in. The agent breaks the work into bite-sized tasks (2-5 minutes each) with exact file paths, complete code snippets, and verification steps. Every task is clear enough for "an enthusiastic junior engineer with poor taste, no judgment, no project context, and an aversion to testing" to follow.

Then comes the magic: subagent-driven-development. The agent dispatches fresh subagents to work through each task, inspecting and reviewing their work in two stages (spec compliance, then code quality). Your main agent can work autonomously for hours without deviating from the plan you approved.

Throughout this process, the test-driven-development skill enforces strict RED-GREEN-REFACTOR: write a failing test, watch it fail, write minimal code to pass, watch it pass, commit. If code gets written before tests, the agent deletes it and starts over.

The Core Workflow: From Idea to Production

Superpowers orchestrates seven skills in a specific sequence to guide your agent from initial idea to production-ready code:

1. brainstorming — Socratic design refinement through questions and validation
2. using-git-worktrees — Creates isolated workspace on a new branch, runs setup, verifies clean test baseline
3. writing-plans — Breaks work into 2-5 minute tasks with exact paths and verification steps
4. subagent-driven-development — Dispatches fresh subagents per task with two-stage review
5. test-driven-development — Enforces RED-GREEN-REFACTOR cycle, deletes code written before tests
6. requesting-code-review — Reviews against plan, reports issues by severity, blocks on critical problems
7. finishing-a-development-branch — Verifies tests pass, presents options (merge/PR/keep/discard), cleans up worktree

The agent checks for relevant skills before every task. These aren't suggestions—they're mandatory workflows that trigger automatically based on context.

Installation Across 10+ AI Coding Platforms

Superpowers supports virtually every major AI coding assistant. Here's how to install it for each platform:

Claude Code

Install from the official marketplace:

/plugin install superpowers@claude-plugins-official

Cursor

In Cursor Agent chat:

/add-plugin superpowers

GitHub Copilot CLI

Register the marketplace and install:

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

Codex App and CLI

In Codex App, click Plugins in the sidebar and install Superpowers from the Coding section. For Codex CLI:

/plugins
superpowers
# Select "Install Plugin"

OpenCode

Fetch and follow installation instructions:

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

Superpowers also supports Antigravity, Factory Droid, Kimi Code, and Pi. If you use multiple platforms, install Superpowers separately for each one.

Real-World Example: Building a REST API with Superpowers

Let's say you want to build a REST API for a todo app. Here's how Superpowers transforms the workflow:

Without Superpowers:

You describe the API. Claude Code immediately generates 500 lines of Express.js code with routes, controllers, and database models. You notice there are no tests, no error handling, and the authentication is broken. You spend the next hour debugging and refactoring.

With Superpowers:

Step 1 — Brainstorming (5 minutes): Claude Code asks questions: "What endpoints do you need? How should authentication work? What database? Should we use JWT or session tokens? What about rate limiting?" You answer, and it presents a design document in three sections for your approval.

Step 2 — Planning (3 minutes): The agent creates 12 tasks: setup project structure, create database schema, implement user model, write user tests, implement auth middleware, write auth tests, create todo model, write todo tests, implement CRUD endpoints, write endpoint tests, add error handling, write integration tests.

Step 3 — Subagent-driven development (45 minutes): The main agent dispatches subagents to work through each task. For each task, the subagent writes a failing test, watches it fail, writes minimal code, watches it pass, and commits. The main agent reviews each subagent's work in two stages.

Step 4 — Code review and finishing (5 minutes): The agent runs all tests, presents a summary of what was built, and asks if you want to merge, create a PR, keep the branch, or discard.

The result: production-ready code with 100% test coverage, proper error handling, authentication, and documentation—all in under an hour.

Key Benefits of Superpowers

• Enforces best practices automatically — TDD, systematic debugging, and structured planning happen without you asking
• Reduces debugging time — Tests are written first, so bugs are caught before code is merged
• Improves code quality — Two-stage code review (spec compliance + quality) catches issues early
• Enables autonomous development — Agents can work for hours without deviating from approved plans
• Works across platforms — Same methodology for Claude Code, Cursor, Copilot, Codex, and 6+ other tools
• Composable skills — Skills trigger automatically based on context, not manual invocation
• Open source and MIT licensed — Free to use, modify, and distribute

Frequently Asked Questions

What AI coding platforms does Superpowers support?

Superpowers supports Claude Code, Cursor, GitHub Copilot CLI, Codex App, Codex CLI, OpenCode, Antigravity, Factory Droid, Kimi Code, and Pi. Installation differs by platform, but the skills and methodology work the same across all of them.

Do I need to manually activate Superpowers skills?

No. Superpowers skills trigger automatically based on context. When you start building something, the brainstorming skill activates. When you approve a design, the planning skill activates. When you start implementing, the TDD skill activates. You don't need to do anything special—your agent just has Superpowers.

Can I use Superpowers with my existing projects?

Yes. Superpowers works with both new projects and existing codebases. For existing projects, the agent will analyze your current code structure during the brainstorming phase and adapt the workflow accordingly.

Does Superpowers work with all programming languages?

Yes. Superpowers is language-agnostic. The skills work with any programming language, framework, or tech stack. The methodology (TDD, planning, code review) applies universally.

How does the subagent-driven-development skill work?

When your plan is approved, the main agent dispatches fresh subagents to work on each task. Each subagent writes tests first, implements code, and commits. The main agent then reviews the work in two stages: first checking spec compliance (does it match the plan?), then checking code quality (is it clean, tested, and maintainable?). Critical issues block progress until they're fixed.

What if I don't want to follow the full workflow?

Superpowers skills are mandatory once installed—they're not suggestions. However, you can disable specific skills by removing them from the skills directory, or uninstall Superpowers entirely if you prefer the standard AI coding workflow.

Is Superpowers free to use?

Yes. Superpowers is open source under the MIT license. You can use it freely for personal and commercial projects. Prime Radiant also offers commercial support and additional tooling for enterprise users.