Open Source Project Watch

Superpowers: 141k Stars—Adding a "Workflow Engine" to Your AI Coding Agent

You use AI for coding, but does it have "methodology"?

Most people use AI for coding like this:

You give it a requirement, and the AI immediately starts writing code. After writing a section, you notice something's wrong, so you ask it to fix it. After fixing it, you find another issue, so you continue revising. After several rounds of back-and-forth, the code becomes increasingly messy, and in the end, you're not even sure what it's actually doing.

Where's the problem? The AI has "capability," but no "methodology."

It can write code, but it can't plan. It can fix bugs, but it doesn't know when to stop and think. It can work under your guidance, but it won't proactively make things better.

Superpowers solves exactly this problem.

141k Stars, an "Agent Workflow" Framework

Superpowers is a complete software development workflow framework, specifically designed for AI coding agents.

At its core: a set of composable "skills," plus initial instructions to ensure your agent uses them correctly.

This isn't a new tool, but rather a "methodology layer" that can be installed on platforms like Claude Code, Cursor, Codex, OpenCode, and others.

How It Works

Step One: Don't Rush to Write Code

When your coding agent sees what you want to build, it doesn't immediately jump into writing code.

Instead, it pauses to ask you: What exactly do you want to do?

Through questioning, it helps you refine requirements, explore alternatives, and then present the design in chunks short enough for you to read and digest.

Step Two: Break Down the Implementation Plan

After you approve the design, it creates a plan clear enough that "an enthusiastic but tasteless, judgment-lacking, project-context-free, test-averse junior engineer" could follow along.

Key emphases: - True Red/Green TDD - YAGNI (You Ain't Gonna Need It) - DRY (Don't Repeat Yourself)

Step Three: Subagent-Driven Development

Once you say "start," it launches a "subagent-driven development" process: the agent completes each engineering task one by one, checks and reviews the work, then moves forward.

Claude can often work autonomously for hours without deviating from the plan you created together.

Core Workflows

Superpowers defines a complete development process:

1. brainstorming

Activated before writing code. Refines rough ideas through questioning, explores alternatives, presents design in segments for validation. Saves design documents.

2. using-git-worktrees

Activated after design approval. Creates isolated workspaces on new branches, runs project setup, verifies clean test baseline.

3. writing-plans

Activated after design approval. Breaks work into small tasks (2-5 minutes each). Each task has precise file paths, complete code, and verification steps.

4. subagent-driven-development

Activated after plan creation. Dispatches new subagents for each task, conducts two-phase reviews (spec compliance, then code quality). When code is bad, it stops to review instead of charging forward.

5. test-driven-development

Activated during implementation. Enforces RED-GREEN-REFACTOR: write failing test → see it fail → write minimal code → see it pass → commit. Deletes code written before tests.

6. requesting-code-review

Activated between tasks. Reviews against the plan, reports issues by severity. Critical issues block progress.

7. finishing-a-development-branch

Activated after task completion. Verifies tests, presents options (merge/PR/keep/discard), cleans up worktrees.

The agent checks relevant skills before any task. This is a mandatory workflow, not a suggestion.

Skill Library

Testing

test-driven-development: RED-GREEN-REFACTOR cycle (includes test anti-pattern reference)

Debugging

systematic-debugging: 4-phase root cause process (includes root cause tracing, defense in depth, condition-based waiting techniques)
verification-before-completion: Ensures it's actually fixed

Collaboration

brainstorming: Socratic design refinement
writing-plans: Detailed implementation plans
executing-plans: Batch execution with checkpoints
dispatching-parallel-agents: Concurrent subagent workflows
requesting-code-review: Pre-review checklist
receiving-code-review: Responding to feedback
using-git-worktrees: Parallel development branches
finishing-a-development-branch: Merge/PR decision workflow
subagent-driven-development: Fast iteration + two-phase review

Installation

Supports multiple platforms:

Claude Code (Official Marketplace)

/plugin install superpowers@claude-plugins-official

Cursor

/add-plugin superpowers

Codex

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

OpenCode

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

Gemini CLI

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

Core Philosophy

Test-Driven Development: Write tests first, always
Systematic Over Ad Hoc: Process over guessing
Reduce Complexity: Simplicity is the primary goal
Evidence Over Claims: Verify before claiming success

Why It's Worth Watching

Most AI coding tools only give you "capability": it can write code, fix bugs, explain logic.

But Superpowers gives you "methodology": it knows when to stop and plan, when to test, when to review.

Capability makes you fast; methodology makes you stable.

141k stars tell us one thing: What truly makes AI coding usable isn't stronger models, but better workflows.

Related Links:

GitHub: https://github.com/obra/superpowers
Author's Blog: https://blog.fsck.com/2025/10/09/superpowers/
Discord: https://discord.gg/35wsABTejz
Author: Jesse Vincent (Prime Radiant)

Superpowers: 141k Stars—Adding a Workflow Engine to Your AI Coding Agent