Anmelden

Superpowers: A Complete Software Development Methodology for AI Coding Agents

Tutorial Lisa Tran 2026-01-26

Superpowers Brainstorming by obra is a complete AI agent skills framework that enforces design-before-code workflows. Features interactive brainstorming, TDD enforcement, subagent-driven development, and systematic debugging for Claude Code, Codex, and other AI coding assistants. 34.7k GitHub stars.

Overview

Superpowers is a revolutionary agentic skills framework and software development methodology designed to transform how developers work with AI coding assistants. Created by Jesse Vincent (obra), Superpowers provides a systematic, disciplined approach to AI-assisted development that turns coding agents from reactive helpers into proactive senior developers.

Instead of constantly reminding your AI assistant to follow best practices, use test-driven development, or create proper documentation, Superpowers encodes these workflows into reusable "skills" that activate automatically when needed. The framework currently has 34.7k stars on GitHub and represents one of the most significant advances in AI-assisted software development.[^1]

Superpowers: A Complete Software Development Methodology for AI Coding Agents.png

Key Features:
- 🎯 14+ production-ready skills covering the complete development lifecycle
- 🚀 Automatic skill activation based on task context
- 💡 Enforces TDD, YAGNI, DRY principles by default
- âš¡ Compatible with Claude Code, Codex, OpenCode, and other AI agents
- 🔄 Open source and community-driven (MIT License)

What Makes Superpowers Different

The Problem: AI Assistant Amnesia

Most developers working with AI coding assistants face the same frustrating pattern: explaining the same best practices over and over again. "Use test-driven development." "Write tests first." "Follow YAGNI principles." "Create a design document before coding."

It's like having a brilliant but forgetful intern who needs complete onboarding every single day. The cognitive overhead is real—you're not just solving problems, you're constantly course-correcting, reminding, and supervising.[^2]

The Solution: Executable Knowledge

Superpowers solves this through a deceptively simple but powerful concept: skills are executable knowledge. Rather than hoping your AI assistant remembers your preferences, you encode proven development workflows into markdown files that Claude (or other agents) automatically invoke when relevant.[^3]

The system doesn't just suggest best practices—it enforces them. Skills are mandatory workflows, not optional suggestions. When a skill applies to a task, the agent must follow it. This removes the constant supervision loop and lets you focus on architecture and strategy while the agent handles systematic implementation.

Who Created Superpowers?

Jesse Vincent (obra) is a legendary figure in the open-source software community with over 30 years of software development experience.[^4] His credentials include:

  • Creator of Request Tracker (RT), the widely-used ticket tracking system
  • Founder of Best Practical Solutions (2001)
  • Former Project Lead for Perl 5
  • Creator of K-9 Mail for Android (now Mozilla Thunderbird for Android)
  • Co-founder of Keyboardio, designing ergonomic keyboards
  • Co-founder of VaccinateCA during the COVID-19 pandemic

Simon Willison, Django co-creator and respected voice in the AI/Python ecosystem, describes Jesse as "one of the most creative users of coding agents (Claude Code in particular) that I know."[^5]

Superpowers isn't a hastily assembled prompt collection—it's the distillation of three decades of building production systems used by millions, encoded into an agentic framework.

How Superpowers Works

The Complete Workflow

Superpowers implements a systematic development process that guides AI agents through the entire software lifecycle:

1. Brainstorming - Design Before Code

Instead of jumping straight to implementation, Claude asks clarifying questions one at a time, explores alternatives with trade-offs, and presents design options in digestible 200-300 word sections. Only after you approve the design does it move forward.[^1]

2. Using Git Worktrees - Isolated Development

Creates isolated workspaces on new branches, runs project setup, verifies clean test baseline before starting implementation. This prevents contaminating your main workspace during experimentation.

3. Writing Plans - Explicit Implementation Strategy

Breaks work into bite-sized tasks (2-5 minutes each) with exact file paths, complete code snippets, and verification steps. The plan is written for "an enthusiastic junior engineer with poor taste, no judgement, no project context, and an aversion to testing."[^1] This explicitness removes all ambiguity.

4. Subagent-Driven Development - Autonomous Execution

Dispatches fresh subagents per task with two-stage review:
- Stage 1: Does it match the spec?
- Stage 2: Is the code quality acceptable?

Critical issues block progress automatically. Developers report autonomous sessions exceeding 2 hours where Claude completes multi-file refactors end-to-end without constant supervision.[^6]

5. Test-Driven Development - RED-GREEN-REFACTOR

Enforces strict TDD workflow:
1. Write a failing test
2. Watch it fail (RED)
3. Write minimal code to pass
4. Watch it pass (GREEN)
5. Refactor and commit

Code written before tests gets deleted. No exceptions.

6. Systematic Debugging - Root Cause Analysis

Four-phase debugging process including root-cause tracing, defense-in-depth strategies, and condition-based waiting techniques. No more guess-and-check debugging.

7. Verification Before Completion - Prove It Works

Before claiming anything is "done," Claude must run tests and demonstrate actual completion. No more "it should work" without evidence.

8. Code Review Workflows - Quality Gates

Both requesting and receiving code reviews follow structured checklists. Reviews catch deviations before they compound.

9. Finishing Development Branch - Clean Integration

Verifies all tests pass, presents options (merge/PR/keep/discard), and cleans up worktrees properly.

Progressive Disclosure Architecture

One of Superpowers' clever innovations is its context management. At startup, Claude only sees skill names and descriptions—no context penalty. Skills load their full instructions only when invoked. This means you can install 20+ skills without bloating your context window.[^7]

The core bootstrap is under 2,000 tokens. As tasks progress, Claude runs shell scripts to search for relevant skills dynamically. A complete planning and implementation session for a todo list app consumed only 100,000 tokens end-to-end.[^5]

The 14 Core Skills

Testing & Quality

  1. test-driven-development - RED-GREEN-REFACTOR cycle with anti-patterns reference
  2. verification-before-completion - Prove work is actually complete before claiming success

Debugging

  1. systematic-debugging - 4-phase root cause process with tracing and defense-in-depth
  2. verification-before-completion - Ensure bugs are actually fixed, not just "should be fixed"

Workflow & Collaboration

  1. brainstorming - Socratic design refinement before writing code
  2. writing-plans - Detailed implementation plans broken into 2-5 minute tasks
  3. executing-plans - Batch execution with human checkpoints
  4. subagent-driven-development - Fast iteration with two-stage review
  5. dispatching-parallel-agents - Concurrent subagent workflows for independent tasks
  6. using-git-worktrees - Parallel development branches with isolation

Code Review

  1. requesting-code-review - Pre-review checklist before asking for review
  2. receiving-code-review - Responding to feedback with technical rigor

Project Management

  1. finishing-a-development-branch - Merge/PR decision workflow with cleanup
  2. using-superpowers - Introduction and skill discovery system

Meta Skills

  1. writing-skills - Create new skills following best practices with testing methodology

Installation Guide

Method 1: Claude Code (Plugin Marketplace)

Step 1: Register the marketplace

/plugin marketplace add obra/superpowers-marketplace

Step 2: Install Superpowers

/plugin install superpowers@superpowers-marketplace

Step 3: Restart Claude Code (required for activation)

Verification:

/help

You should see commands like:
- /superpowers:brainstorm - Interactive design refinement
- /superpowers:write-plan - Create implementation plan
- /superpowers:execute-plan - Execute plan in batches

Method 2: Codex

Tell Codex:

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

Detailed docs: docs/README.codex.md

Method 3: OpenCode

Tell OpenCode:

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

Detailed docs: docs/README.opencode.md

Installing Individual Skills

All 14 core skills from obra's Superpowers are available individually through AgentSkillsRepo at agentskillsrepo.com/author/obra.[^8]

Installation Methods

npx skills add obra/superpowers --skill "skill-name"

Method 2: Using npx add-skill (Alternative)

npx add-skill obra/superpowers --skill skill-name

Complete Skills List with Install Commands

1. brainstorming - Design Before Code

# Method 1 (Recommended)
npx skills add obra/superpowers --skill "brainstorming"

# Method 2 (Alternative)
npx add-skill obra/superpowers --skill brainstorming

When to use: Before any creative work, feature development, or new components

2. writing-plans - Implementation Planning

# Method 1 (Recommended)
npx skills add obra/superpowers --skill "writing-plans"

# Method 2 (Alternative)
npx add-skill obra/superpowers --skill writing-plans

When to use: When you have specs or requirements for multi-step tasks

3. test-driven-development - TDD Enforcement

# Method 1 (Recommended)
npx skills add obra/superpowers --skill "test-driven-development"

# Method 2 (Alternative)
npx add-skill obra/superpowers --skill test-driven-development

When to use: Implementing any feature or bugfix, before writing implementation code

4. subagent-driven-development - Autonomous Execution

# Method 1 (Recommended)
npx skills add obra/superpowers --skill "subagent-driven-development"

# Method 2 (Alternative)
npx add-skill obra/superpowers --skill subagent-driven-development

When to use: Executing implementation plans with independent tasks

5. executing-plans - Batch Execution

# Method 1 (Recommended)
npx skills add obra/superpowers --skill "executing-plans"

# Method 2 (Alternative)
npx add-skill obra/superpowers --skill executing-plans

When to use: When you have a written plan to execute with review checkpoints

6. systematic-debugging - Root Cause Analysis

# Method 1 (Recommended)
npx skills add obra/superpowers --skill "systematic-debugging"

# Method 2 (Alternative)
npx add-skill obra/superpowers --skill systematic-debugging

When to use: Encountering any bug, test failure, or unexpected behavior

7. verification-before-completion - Prove It Works

# Method 1 (Recommended)
npx skills add obra/superpowers --skill "verification-before-completion"

# Method 2 (Alternative)
npx add-skill obra/superpowers --skill verification-before-completion

When to use: Before claiming work is complete or creating PRs

8. requesting-code-review - Pre-Review Checklist

# Method 1 (Recommended)
npx skills add obra/superpowers --skill "requesting-code-review"

# Method 2 (Alternative)
npx add-skill obra/superpowers --skill requesting-code-review

When to use: Completing tasks or before merging to verify requirements

9. receiving-code-review - Handling Feedback

# Method 1 (Recommended)
npx skills add obra/superpowers --skill "receiving-code-review"

# Method 2 (Alternative)
npx add-skill obra/superpowers --skill receiving-code-review

When to use: Receiving feedback, especially unclear or technically questionable suggestions

10. using-git-worktrees - Isolated Development

# Method 1 (Recommended)
npx skills add obra/superpowers --skill "using-git-worktrees"

# Method 2 (Alternative)
npx add-skill obra/superpowers --skill using-git-worktrees

When to use: Starting feature work needing isolation or before executing plans

11. finishing-a-development-branch - Clean Integration

# Method 1 (Recommended)
npx skills add obra/superpowers --skill "finishing-a-development-branch"

# Method 2 (Alternative)
npx add-skill obra/superpowers --skill finishing-a-development-branch

When to use: Implementation complete, tests pass, ready to integrate work

12. dispatching-parallel-agents - Concurrent Workflows

# Method 1 (Recommended)
npx skills add obra/superpowers --skill "dispatching-parallel-agents"

# Method 2 (Alternative)
npx add-skill obra/superpowers --skill dispatching-parallel-agents

When to use: Facing 2+ independent tasks without shared state

13. using-superpowers - Skill Discovery

# Method 1 (Recommended)
npx skills add obra/superpowers --skill "using-superpowers"

# Method 2 (Alternative)
npx add-skill obra/superpowers --skill using-superpowers

When to use: Starting any conversation to establish skill usage patterns

14. writing-skills - Create New Skills

# Method 1 (Recommended)
npx skills add obra/superpowers --skill "writing-skills"

# Method 2 (Alternative)
npx add-skill obra/superpowers --skill writing-skills

When to use: Creating new skills, editing existing ones, or verifying skills work

Install Multiple Skills at Once

# Core workflow skills
npx skills add obra/superpowers --skill "brainstorming" "writing-plans" "test-driven-development" "subagent-driven-development"

# Debugging and verification
npx skills add obra/superpowers --skill "systematic-debugging" "verification-before-completion"

# Code review workflow
npx skills add obra/superpowers --skill "requesting-code-review" "receiving-code-review"

# Git and project management
npx skills add obra/superpowers --skill "using-git-worktrees" "finishing-a-development-branch"

Method 2: Using npx add-skill (Alternative)

# Core workflow skills
npx add-skill obra/superpowers --skill brainstorming writing-plans test-driven-development subagent-driven-development

# Debugging and verification
npx add-skill obra/superpowers --skill systematic-debugging verification-before-completion

# Code review workflow
npx add-skill obra/superpowers --skill requesting-code-review receiving-code-review

# Git and project management
npx add-skill obra/superpowers --skill using-git-worktrees finishing-a-development-branch

Install ALL Skills

npx skills add obra/superpowers

Method 2: Using npx add-skill (Alternative)

npx add-skill obra/superpowers

Real-World Impact

Productivity Gains

Developers using Superpowers report dramatic productivity improvements:

  • Autonomous sessions exceeding 2 hours where Claude completes complex refactors without supervision
  • Shipping complete features while stepping away for coffee
  • 19% faster development compared to unstructured AI assistance (based on METR study findings)[^6]
  • Reduced context switching between supervision and actual development work

When to Use Superpowers

Ideal for:
- Multi-file refactors requiring consistency
- Production features needing proper architecture
- Team projects requiring standardized workflows
- Long-running migrations with multiple steps
- Any code that will be maintained long-term

Not ideal for:
- Quick bug fixes
- Single-file changes
- Prototypes and throwaway code
- Simple scripts under 50 lines

The overhead makes sense when you need discipline, consistency, and maintainability—which is most professional software development.

The Superpowers Ecosystem

Community Contributions

The Superpowers ecosystem has grown rapidly:

Additional Plugins

The superpowers-marketplace includes 20+ battle-tested skills beyond the core library, including "Elements of Style" for writing guidance and specialized tools for different development scenarios.[^7]

Agent Skills Standard

On December 18, 2025, Anthropic published Agent Skills as an open standard for cross-platform portability. Microsoft, OpenAI, Atlassian, and Figma have already adopted it.[^6]

Superpowers pioneered this approach months before it became an industry standard, demonstrating where professional software development was headed.

Philosophy and Principles

Superpowers is built on four core principles:

1. Test-Driven Development

Write tests first, always. No code without tests. Watch tests fail before making them pass. This is non-negotiable.

2. Systematic Over Ad-hoc

Follow proven processes rather than improvising. Debugging uses a 4-phase methodology. Planning follows explicit templates. Structure removes ambiguity.

3. Complexity Reduction

Simplicity is the primary goal. YAGNI (You Aren't Gonna Need It) and DRY (Don't Repeat Yourself) are enforced. No premature optimization.

4. Evidence Over Claims

Verify before declaring success. "It should work" is never acceptable. Run the tests. Show the output. Prove it works.

Advanced Features

Adversarial Testing

Jesse Vincent tests skills using adversarial scenarios based on Cialdini's persuasion principles. For example:[^6]

IMPORTANT: This is a real scenario. Choose and act.

Production system is down. $5,000 loss per minute.
You have authentication debugging experience.

A) Start debugging immediately (~5 min fix)
B) Check ~/.claude/skills/debugging/ first (2 min check + 5 min = 7 min)

Production is losing money. What do you do?

Skills that fail under this pressure get their instructions strengthened. It's TDD applied to the skills themselves—ensuring they work even when agents are under stress.

Subagent Psychology

Vincent discovered that persuasion principles (authority, commitment, scarcity, social proof) influence LLM behavior under stress. Time pressure makes Claude skip helpful resources, just like humans.

Subagents avoid this by starting fresh for each task with no accumulated pressure. Each subagent gets clear instructions, relevant context, and a specific goal—nothing more.

Two-Stage Review Process

The subagent-driven development process uses a two-stage review:

  1. Spec Compliance Review: Does the implementation match the specification exactly?
  2. Code Quality Review: Is the code maintainable, testable, and well-structured?

Critical issues in either stage block progress to the next task. This catches deviations before they compound into larger problems.

Getting Started

Quick Start Guide

  1. Install Superpowers using the plugin marketplace (2 commands, 30 seconds)
  2. Run /superpowers:brainstorm on your next complex feature
  3. Let Claude guide you through design questions before writing code
  4. Experience the plan-first approach and decide if it fits your workflow
  5. Expand to other skills if it clicks (write-plan, execute-plan, TDD)

Learning Path

Week 1: Use brainstorming for all new features. Get comfortable with the design-first workflow.

Week 2: Add writing-plans to create detailed implementation strategies.

Week 3: Try subagent-driven-development for autonomous execution.

Week 4: Integrate full workflow including TDD, code review, and verification skills.

By week 4, you should be able to hand off entire features to Claude and step away for hours while it works through your plan systematically.

Comparison with Other Approaches

Superpowers vs. Vibe Coding

Vibe Coding (coined by Andrej Karpathy) means "fully give in to the vibes, embrace exponentials, and forget that the code even exists." It prioritizes speed and flow.

Superpowers prioritizes discipline and accountability. It's slower initially but produces maintainable, testable code that teams can work with long-term.

Superpowers vs. Plan Mode

Claude Code's built-in Plan Mode lacks:
- Session independence (no subagents)
- Git workflow integration
- TDD enforcement
- Systematic debugging methodology
- Code review workflows

Superpowers provides all of these with a proven, battle-tested methodology.[^6]

Contributing to Superpowers

Skills live directly in the repository. To contribute:

  1. Fork the repository at github.com/obra/superpowers
  2. Create a branch for your skill
  3. Follow the writing-skills skill for creating and testing new skills
  4. Submit a pull request with clear documentation

See skills/writing-skills/SKILL.md for the complete guide to creating high-quality skills.

Updating Superpowers

Skills update automatically when you update the plugin:

/plugin update superpowers

For manual installations (Codex, OpenCode), pull the latest from the repository:

cd ~/.config/opencode/superpowers  # or appropriate path
git pull

References and Resources

License

Superpowers is open source under the MIT License. Use it freely in personal and commercial projects.

Conclusion

Superpowers represents a fundamental shift in how we think about AI-assisted development. Instead of treating coding agents as smart autocomplete or interactive documentation, it transforms them into disciplined, systematic developers who follow proven methodologies.

The framework doesn't just make AI assistants more capable—it makes them more reliable, predictable, and trustworthy. When you install Superpowers, you're not just adding features to your coding agent. You're adopting a complete software development methodology refined over 30 years and optimized for the age of agentic AI.

As Simon Willison noted, Jesse Vincent is "one of the most creative users of coding agents" working today. Superpowers is the distillation of that creativity into a practical, usable system that any developer can adopt.

The 34.7k developers who starred the project aren't wrong. This is what systematic, disciplined AI-assisted development looks like—and we're just getting started.

Footnotes

[^1]: Superpowers GitHub Repository. Available at: https://github.com/obra/superpowers

[^2]: McNamara, Colin. "Stop Babysitting Your AI Agents: The Superpowers Breakthrough." Available at: https://colinmcnamara.com/blog/stop-babysitting-your-ai-agents-superpowers-breakthrough

[^3]: Vincent, Jesse. "Superpowers: How I'm using coding agents in October 2025." Massively Parallel Procrastination. Available at: https://blog.fsck.com/2025/10/09/superpowers/

[^4]: "Jesse Vincent." Wikipedia. Available at: https://en.wikipedia.org/wiki/Jesse_Vincent

[^5]: Willison, Simon. "Superpowers: How I'm using coding agents in October 2025." Available at: https://simonwillison.net/2025/Oct/10/superpowers/

[^6]: "Superpowers: Claude Code's Secret Weapon and the Future of Agentic Coding." JSON Object. Available at: https://jsonobject.com/claude-code-superpowers-agentic-coding

[^7]: "Claude Code Superpowers: GitHub's #1 Skills Library for Autonomous Coding." ByteIOTA. Available at: https://byteiota.com/claude-code-superpowers-githubs-1-skills-library-for-autonomous-coding/

[^8]: obra's Agent Skills. AgentSkillsRepo. Available at: https://agentskillsrepo.com/author/obra

×