Superpowers Method

Source Excerpt

Executive Summary

Superpowers is a complete software development workflow for AI coding agents, built on composable "skills" that activate automatically. Instead of jumping into code, agents using Superpowers first extract specifications through conversation, present designs in digestible chunks for validation, create detailed implementation plans (2-5 minute tasks), then execute via subagent-driven development with two-stage review.

Strategic Value for retired internal project: Superpowers is the original inspiration for Julius's governance approach and the Superpowers Method we follow. Created by Jesse Vincent (Prime Radiant), it validates our spec-first, test-driven, subagent-executed workflow. Direct comparison point with GitHub's Spec-Kit — both achieve similar goals via different mechanisms (skills vs CLI commands).

How It Works

The Core Flow

1. Brainstorming (activates before writing code)

• Agent asks clarifying questions instead of coding immediately
• Teases out real requirements from conversation
• Presents design in sections for validation
• Saves design document to repository

1. Using Git Worktrees (after design approval)

• Creates isolated workspace on new branch
• Runs project setup
• Verifies clean test baseline

1. Writing Plans (with approved design)

• Breaks work into bite-sized tasks (2-5 minutes each)
• Every task has exact file paths, complete code examples, verification steps
• Emphasizes YAGNI (You Aren't Gonna Need It), DRY principles

1. Subagent-Driven Development (with plan in hand)

• Dispatches fresh subagent per task
• Two-stage review: spec compliance → code quality
• Continues autonomously for hours without deviating from plan

1. Test-Driven Development (during implementation)

• Enforces RED-GREEN-REFACTOR cycle
• Write failing test, watch it fail
• Write minimal code, watch it pass
• Commits after each passing test
• Deletes code written before tests

1. Requesting Code Review (between tasks)

• Reviews against original plan
• Reports issues by severity
• Critical issues block progress

1. Finishing a Development Branch (when tasks complete)

• Verifies all tests pass
• Presents options: merge, PR, keep branch, discard
• Cleans up worktree

Key Principle: Agent checks for relevant skills before any task — mandatory workflows, not suggestions.

Installation by Platform

Claude Code (Official Marketplace)

/plugin install superpowers@claude-plugins-official

Claude Code (Community Marketplace)

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

Cursor

/add-plugin superpowers
# Or search "superpowers" in plugin marketplace

Codex CLI

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

OpenCode CLI

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

GitHub Copilot CLI

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

Gemini CLI

gemini extensions install https://GitHub.com/obra/superpowers
# Update: gemini extensions update superpowers

Verify Installation

Start new session and ask for something that should trigger a skill (e.g., "help me plan this feature"). Agent should automatically invoke relevant Superpowers skill.

Skills Library

Testing Skills

Debugging Skills

Systematic Debugging Includes:

• Root cause tracing methodology
• Defense in depth strategies
• Condition-based waiting techniques

Collaboration Skills

Meta Skills

Philosophy

Superpowers is built on four core principles:

1. Test-Driven Development

Write tests first, always. No exceptions. Tests are the specification of correct behavior.

2. Systematic Over Ad-Hoc

Process over guessing. Follow the skills, don't wing it. Consistency compounds.

3. Complexity Reduction

Simplicity as primary goal. YAGNI (You Aren't Gonna Need It). DRY (Don't Repeat Yourself). Delete code written before tests.

4. Evidence Over Claims

Verify before declaring success. Run the tests. Show me the logs. Trust but verify.

Comparison: Superpowers vs. Spec-Kit

Key Differences

Superpowers Strengths:

• Automatic skill activation — no need to remember commands
• Deep TDD integration with anti-pattern references
• Native subagent-driven development workflow
• Git worktree isolation built-in
• Two-stage review (spec compliance + code quality)

Spec-Kit Strengths:

• Official GitHub backing and roadmap
• 20+ community extensions (AIDE, Fleet, DocGuard, etc.)
• Enterprise features (air-gapped install, OAuth, audit logs)
• More explicit workflow phases (Constitution → Spec → Plan → Tasks → Implement)

Verdict: Superpowers is more automatic and integrated — skills trigger without user intervention. Spec-Kit is more explicit and extensible — clear phases, rich extension ecosystem. Both validate the spec-driven approach; choice depends on preference for automation vs explicitness.

Alignment with retired internal project

Julius Governance Model Validation ✅

Superpowers validates core Julius design decisions:

Source excerpt truncated at 220 of 415 lines. Open the canonical wiki path above for the full page.