Superpowers: The Agentic Skills Framework That Lets AI Coding Agents Work Autonomously for Hours

Published: 2026-05-17 Reading: 8 min AI Coding / Agentic Development / TDD / Software Methodology

Here's a familiar scenario: you ask an AI coding agent to build a feature, and it either goes off-track halfway through, produces inconsistent code quality, or breaks your existing tests. The problem isn't the AI's capability — it's the lack of a structured development methodology.

That's exactly what Superpowers solves. It's an open-source project trending on GitHub, created by Jesse (obra), that provides a complete software development methodology for AI coding agents. It's not a new tool — it's a set of automatically-triggered skills that turn your Claude Code, Codex CLI, Cursor, Gemini CLI, or other AI coding tools into a disciplined senior engineer.

Once installed, you don't need to manually invoke anything. The agent triggers the right skills at the right time, guiding the entire development flow from brainstorming to code review.

What Is Superpowers
Why It's Different
Core Workflow: 7 Auto-Triggered Skills
Core Philosophy: TDD, YAGNI, DRY
Installation
Real-World Example
Supported AI Coding Tools
How It Compares
Conclusion

What Is Superpowers

Superpowers is fundamentally a software development methodology designed for AI coding agents. It takes the engineering practices that human developers have refined over decades — TDD (Test-Driven Development), code review, branch management, task decomposition — and translates them into skills that AI agents can understand and execute.

Think of it as installing "senior engineer habits" into your AI. Not the "write me a function" kind of interaction, but the full workflow: think before you code, break work into small tasks, write tests first, verify after each step, review before merging.

        Key insight: Superpowers designs plans to be "clear enough for an enthusiastic junior engineer with poor taste." The AI doesn't need to "understand" your intent — the plan itself contains all the details needed for execution.
      

Why It's Different

The market isn't short on AI coding tools, but Superpowers addresses a more fundamental problem: how to make AI agents work autonomously for hours while maintaining quality.

Most AI coding tools suffer from:

Context drift: The agent forgets what it was supposed to be doing mid-task
Inconsistent quality: Without tests, code quality varies wildly
No structure: Tasks aren't decomposed, so the agent tries to do everything at once
No verification: Code gets written and that's it — nobody checks

Superpowers solves these problems through a chain of automatically-triggered skills. Each skill is a self-contained module that the agent calls at the appropriate moment, ensuring the entire development process stays on track.

Core Workflow: 7 Auto-Triggered Skills

The heart of Superpowers is 7 skills that form a complete development pipeline:

1. Brainstorming

Before writing any code, the agent first figures out what you actually want. Instead of jumping straight to implementation, it asks a series of clarifying questions:

What problem are you really trying to solve?
Are there existing solutions to reference?
What are the expected behaviors and edge cases?

Then it explores different implementation approaches, presenting the design in sections so you can align on the solution before any code is written. This step alone prevents enormous amounts of rework.

2. Using Git Worktrees

Once the design is confirmed, the agent automatically creates an isolated workspace:

Creates a Git worktree on a new branch
Runs project setup (installing dependencies, etc.)
Verifies the test baseline is clean (all tests pass)

This ensures development work doesn't pollute your main branch, and can be cleanly merged or discarded when done.

3. Writing Plans

This is one of Superpowers' most critical skills. The agent decomposes the entire development task into small 2-5 minute tasks, each containing:

Exact file paths to be modified
Complete code changes
Verification steps (how to confirm the task is done)

This plan isn't a human-readable summary — it's a precise execution guide for the AI. Each step is small enough that it can be executed without "understanding" the overall architecture.

4. Subagent-Driven Development

This is Superpowers' most innovative design. Each small task isn't executed by the main agent directly — it's dispatched to a fresh subagent. The benefits:

Each subagent has a clean context, uncontaminated by previous conversation
After execution, there's a two-stage review: first checking spec compliance, then code quality
If a subagent fails, it can be re-dispatched without affecting overall progress

5. Test-Driven Development

Superpowers strictly enforces the RED-GREEN-REFACTOR cycle:

RED: Write a failing test first
GREEN: Run the test, confirm it actually fails
GREEN: Write the minimum code to make the test pass
REFACTOR: Clean up the code while keeping tests green
COMMIT: Commit the code

        Strict rule: If the agent writes business code before writing tests, it deletes that code and writes the tests first. This isn't a suggestion — it's a hard-enforced rule.
      

6. Requesting Code Review

After each task completes, the agent automatically initiates a code review:

Checks implementation against the plan
Reports issues by severity level
Critical issues block progress — they must be fixed before continuing

This means you don't need to manually review every line of code — the agent handles the first round of quality assurance itself.

7. Finishing a Development Branch

When all tasks are complete and reviewed, the agent:

Verifies all tests pass
Presents options: merge to main, create a PR, keep the branch, or discard
Cleans up the Git worktree

From start to finish, the agent runs autonomously. You only need to confirm the design direction at the beginning and choose a handling option at the end. The entire middle process requires no intervention.

Core Philosophy: TDD, YAGNI, DRY

Superpowers isn't a random collection of tricks — it's built on a clear engineering philosophy:

TDD (Test-Driven Development)

Tests aren't an afterthought — they're the starting point of development. By writing tests first, the agent knows exactly what "done" looks like. This is far more reliable than "write code and see if it works."

YAGNI (You Aren't Gonna Need It)

Don't write features you don't need right now. AI agents are particularly prone to this — you ask for a user system and it might throw in role-based access control, a logging framework, and a message queue. Superpowers constrains this tendency through strict planning and review.

DRY (Don't Repeat Yourself)

Code duplication is a maintenance nightmare. Superpowers' review phase checks for repeated logic, ensuring every piece of functionality has a single source of truth.

Installation

Installation depends on which AI coding tool you're using:

Claude Code

The simplest method — install via the plugin marketplace:

/plugin install superpowers@claude-plugins-official

No additional configuration needed after installation. Superpowers' skills trigger automatically at the right moments.

Codex CLI / Codex App

Add Superpowers' skill files to your project configuration. See the GitHub repository README for details.

Cursor

Import Superpowers' skill files in your Cursor rules configuration. They'll be read by the agent as part of the system prompt.

Other Tools

Superpowers also supports Gemini CLI, OpenCode, Factory Droid, GitHub Copilot CLI, and more. Basically, if your AI coding tool supports custom instructions or a skill system, Superpowers will work.

Tip: Regardless of which tool you use, the effect is the same — skills are automatically triggered. You don't need to remember any commands or shortcuts.

Real-World Example

Suppose you want an AI agent to implement a "user authentication system." Without Superpowers, you'd probably get a pile of untested code. With Superpowers, here's what happens:

Brainstorming: The agent asks — JWT or sessions? What password hashing algorithm? OAuth support needed? Rate limiting?
Create worktree: Set up an isolated workspace on branch feature/user-auth
Write plan: Break into 8 small tasks (2-5 min each) — user model, password hashing, JWT generation, login endpoint, signup endpoint, middleware, tests, documentation
Execute sequentially: Each task dispatched to a subagent — write test first, then implementation, then automatic review
Code review: Agent checks for security vulnerabilities, code duplication, test coverage gaps
Finish branch: All tests pass — choose to merge, PR, or keep

The entire process might take 2-3 hours, but you only need to answer a few questions at the start and make one choice at the end. Everything in between is fully autonomous.

Supported AI Coding Tools

One of Superpowers' biggest strengths is cross-tool compatibility. Currently supported tools include:

Claude Code — Anthropic's official coding tool, one-click install via plugin marketplace
Codex CLI — OpenAI's command-line coding tool
Codex App — OpenAI's desktop coding application
Factory Droid — Factory's AI coding assistant
Gemini CLI — Google's command-line AI tool
OpenCode — Open-source terminal AI coding tool
Cursor — VS Code-based AI IDE
GitHub Copilot CLI — GitHub's command-line coding assistant

No matter which tool you prefer, Superpowers integrates seamlessly and provides a consistent development experience.

How It Compares

The AI coding space isn't short on methodologies, but Superpowers makes several unique design decisions:

vs raw code generation: Most AI tools are "you say, it writes." Superpowers adds a complete engineering process
vs manual prompt engineering: You don't need to craft elaborate prompts — skills trigger automatically
vs standalone TDD tools: Superpowers isn't just TDD — it's a full methodology from brainstorming to code review
vs other agent frameworks: Superpowers isn't a framework — it's a methodology that doesn't depend on specific code structure or directory layout

        Subagent-driven development is Superpowers' most unique innovation. By assigning a fresh subagent to each task, it solves the context pollution problem in long conversations while maintaining code quality through two-stage review.
      

Conclusion

Superpowers represents a new direction in AI coding: not making AI write more code, but making AI write better code.

Its core value can be summarized in three points:

Automated engineering process: TDD, code review, branch management — the fundamentals of software engineering, now executed by AI
Quality assurance: Test-driven development, subagent review, and strict planning ensure code quality
Cross-tool compatibility: Supports 8 major AI coding tools with no platform lock-in

If you're using Claude Code, Codex, Cursor, or any other AI coding tool, Superpowers is worth trying. One install command turns your AI agent from "occasionally useful" to "consistently reliable."

Repository: github.com/obra/superpowers