Superpowers: The Agentic Skills Framework That Makes Claude Code Actually Think Before Coding

The Problem With Every AI Coding Agent Out of the Box

You open Claude Code. You type "build me a user authentication system." And within seconds it's already writing UserController.cs — no questions asked, no design discussion, no test strategy. Five hundred lines later, you have something that compiles but doesn't match what you actually needed.

This is the default behavior of every coding agent. Fast. Confident. Frequently wrong about the important parts.

Superpowers (github.com/obra/superpowers) is a plugin that changes that contract. Instead of jumping straight to code, the agent is forced to think first — through a structured sequence of skills that mirror how a disciplined senior engineer actually works.

Is It Like get-shit-done?

Short answer: no. They operate at completely different layers.

┌─────────────────────────────────────────────────┐
│              get-shit-done (GSD)                │
│  → Workflow methodology for humans              │
│  → Checklists, git conventions, task mgmt      │
│  → You follow the process manually             │
└─────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────┐
│              obra/superpowers                   │
│  → Plugin installed INTO the AI agent           │
│  → Skills auto-trigger based on context         │
│  → The agent follows the process, not you       │
└─────────────────────────────────────────────────┘

GSD is a discipline system for humans. Superpowers is a behavior injection layer for AI agents. You could use both — they don't conflict.

How Superpowers Works

Once installed, the agent loads a set of skills — markdown files that define when and how to invoke a specific workflow. The agent checks for relevant skills before any task. These are mandatory workflows, not suggestions.

You: "Add a payment integration"
     │
     ▼
[brainstorming] ──→ Clarify scope, explore alternatives
     │                 Output: design doc
     ▼
[using-git-worktrees] ──→ Isolated branch, clean baseline
     │
     ▼
[writing-plans] ──→ Tasks broken to 2-5 min chunks
     │               Each: exact file path + code + verify step
     ▼
[subagent-driven-development]
     │   ├─ subagent picks up Task #1
     │   ├─ Stage 1 review: spec compliance
     │   ├─ Stage 2 review: code quality
     │   └─ repeat per task
     ▼
[test-driven-development] ──→ RED → GREEN → REFACTOR
     │                         enforced at every task
     ▼
[requesting-code-review] ──→ Critical issues block progress
     │
     ▼
[finishing-a-development-branch]
     └─ merge / open PR / discard

The key insight: the agent cannot skip steps. Brainstorming fires before design. Planning fires before implementation. TDD fires before any production code gets committed. It's structured like a pipeline, not a checklist you can ignore.

The Skills Library

Superpowers ships with skills across three categories:

Testing

test-driven-development — RED-GREEN-REFACTOR cycle. Includes anti-pattern reference. Code written before tests gets deleted.

Debugging

systematic-debugging — 4-phase root cause process. No more "try changing this random thing."
verification-before-completion — Prove it's fixed, don't assume.

Collaboration / Planning

brainstorming — Socratic design refinement before any code
writing-plans — Granular tasks, not vague milestones
executing-plans — Batch execution with human checkpoints
dispatching-parallel-agents — Concurrent subagent workflows
requesting-code-review / receiving-code-review — Pre/post review workflow
using-git-worktrees — Parallel dev branches, isolated environments
finishing-a-development-branch — Merge decision workflow
subagent-driven-development — Fast iteration with two-stage review

Installation

Claude Code (Official Marketplace)

/plugin install superpowers@claude-plugins-official

Claude Code (via custom marketplace)

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

Cursor Agent

/add-plugin superpowers

Or search "superpowers" in the plugin marketplace inside Cursor.

Codex

Tell the agent:

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

Verify

Start a new session and prompt:

"help me plan this feature"

If the agent invokes brainstorming instead of writing code immediately — it's working.

Before vs After: The Actual Difference

❌ Without Superpowers
──────────────────────
You: "add payment integration"
Agent: [writes 600 lines of Stripe code]
You: "wait, we use PayOS"
Agent: [rewrites 600 lines]
You: "also needs refund flow"
Agent: [adds more untested code]
3 hours later: works in dev, breaks in prod

✅ With Superpowers
──────────────────────
You: "add payment integration"
Agent: "Which provider? What flows? Edge cases?"
You: [answers]
Agent: [shows design doc, waits for approval]
Agent: [creates git worktree on new branch]
Agent: [writes 8 tasks, 2-5 min each]
Agent: [subagent executes Task 1, writes test first]
Agent: [review: spec ✓, quality ✓]
Agent: [continues to Task 2...]
3 hours later: works in dev, works in prod, has tests

What This Means for Teams Using Cursor Enterprise

If your team is already running Cursor Enterprise with Claude models, Superpowers is a low-effort force multiplier. Instead of each developer prompting the agent differently and getting wildly inconsistent results, every session starts from the same structured baseline: spec → plan → TDD → review.

The skills are also extensible. You can write custom skills for your domain — think optimizely-content-creation, azure-devops-task-sync, or etm-timesheet-logging — and the agent will pick them up automatically. The writing-skills skill ships with a testing methodology to validate your custom skills before committing them to the team.

Verdict

Superpowers solves the right problem. The bottleneck in AI-assisted development isn't speed — agents are already fast enough. The bottleneck is alignment: does the agent understand what you actually want before it starts building?

Forcing a brainstorming → planning → TDD loop before every task adds maybe 10 minutes upfront and saves hours of rework downstream. For any team doing serious development with Claude Code or Cursor, this is worth installing.

152k stars and 13k forks as of April 2026. The community clearly agrees.

→ github.com/obra/superpowers