As of posting time, obra/superpowers sits at 276k star count on GitHub. That number alone is enough to make it the first "AI coding agent framework" a lot of newcomers ever hear about — which is exactly the problem I want to head off in this post.

The star count isn't the main story. The main story is this: most people use AI coding assistants like autocomplete with extra steps. You paste a giant prompt, get code back, hope it works, then debug the chaos that follows. Superpowers flips that. It gives you a repeatable workflow for thinking first, planning second, coding third.

But here's the part that trips up new users — I've seen it happen in my own circles, and I want to save you the confusion: Superpowers is one project in a much bigger, fast-moving ecosystem of skills and plugins for coding agents like Claude Code, OpenCode, Codex CLI, and Cursor. If you walk away from this post thinking Superpowers is the ecosystem, you're going to miss a lot of useful tooling. So this post covers both: how Superpowers works, and where it sits among the other options you'll bump into once you start looking.

Why AI Coding Often Feels Fast — Then Falls Apart

New users see quick output and assume the productivity problem is solved. Then reality hits:

  • Requirements drift mid-build.
  • Tests come late, or never.
  • The agent "finishes" a task without proof it actually works.
  • Code review turns into cleanup theater.
  • A small bugfix quietly mutates into an accidental rewrite.

The root issue is that there are no process guardrails. AI follows instructions — it doesn't create strong engineering discipline on its own. That's exactly the gap Superpowers (and its various cousins in the ecosystem) are built to close.

What Superpowers Actually Is

Superpowers is an open-source skill framework plus a development methodology for coding agents. It's not a single feature — it's a system of workflows with trigger rules that decide when each piece of the process kicks in.

The project describes itself as an agentic skills framework and software development methodology built by Jesse Vincent and the team at Prime Radiant. The core idea: skills activate before action. Your agent doesn't jump straight into writing code. Instead it gets pushed through structured phases — clarify intent, design, plan, execute, verify, review, finish.

That's what turns an AI coding assistant from a "code generator" into a "process follower."

One practical note if you're setting this up: Superpowers supports multiple agent harnesses — Claude Code, Codex CLI, Codex App, Cursor, Factory Droid, OpenCode, and GitHub Copilot CLI. Each harness needs its own separate install step, so if you (like me) bounce between multiple tools depending on the day, you'll be installing it more than once.

I've personally got it running in GitHub Copilot CLI, Claude Code, and OpenCode — three different harnesses, three separate installs, same underlying skill set in each one. That's the part that surprised me the first time: the workflow discipline transfers cleanly even though the CLI, the config paths, and the exact commands differ per tool. If you're on a harness I haven't listed here — Cursor, Codex CLI, Factory Droid, or something newer that isn't in this post yet — there's a good chance it's compatible too, since Superpowers and most of the plugins in this space are built around the portable Agent Skills format rather than being locked to one vendor. Worth checking the project's docs for your specific harness before assuming, but don't assume it won't work just because your tool isn't in my list above.

Core Workflow (Beginner Version)

Here's the practical flow, simplified for first-time AI coders:

  1. Brainstorming first. Before any code gets written, refine what you actually want. Clarify purpose, constraints, and success criteria. Vague asks create vague code.

  2. Design approval gate. The agent proposes an approach, and you approve intent before implementation starts. This catches wrong direction early, when it's still cheap to fix.

  3. Write the plan before execution. Work gets broken into small tasks with exact files and verification steps attached. Less context drift, easier to review.

  4. Subagent or batch execution. Work happens task-by-task, often dispatched to dedicated subagents. Isolation keeps you from ending up with one giant messy run.

  5. Test-driven loop during implementation. A red-green-refactor pattern gets enforced by the skill itself. Confidence comes from tests passing, not from the agent's optimistic summary of what it did.

  6. Code review checkpoints. A review skill checks plan compliance and code quality, separating "done" from "actually good."

  7. Finish the branch with an explicit decision. Merge, PR, keep, or discard — decided only after verification, so half-baked output doesn't silently ship.

This workflow is boring on purpose. Boring process ships reliable code.

Skills New Users Should Understand First

Start with these skill names from the repo:

  • brainstorming — turns a rough request into a clear design.
  • writing-plans — creates a concrete, checkable task list.
  • test-driven-development — keeps the implementation honest.
  • requesting-code-review — enforces a quality gate before merge.
  • verification-before-completion — the "prove it works" discipline.
  • finishing-a-development-branch — closes the loop cleanly instead of leaving a dangling branch.

You don't need every advanced pattern on day one. Use these five or six consistently and the quality jump is immediate.

Final Take

If you're new to AI coding, the biggest upgrade isn't a "better model," a "longer context window," or a "secret prompt template." It's a disciplined workflow.

Superpowers gives you that discipline in reusable skills: think before building, plan before editing, test before claiming, verify before finishing. It's a genuinely great place to start.

Just don't stop there. obra/superpowers grabs attention because of the star count, but the process it teaches — and the wider ecosystem of plugins that build on the same idea — is what actually keeps you shipping reliable code. Try Superpowers on one small feature this week. Judge it by defects prevented, not lines generated. Then, once you've got the process habit down, spend twenty minutes browsing the official marketplace and see what else fits your workflow.