Series Preface

If you’re using Claude Code, Cursor, or other AI coding assistants, Superpowers can fundamentally change how you build software. It’s an open-source project by @obra. It already has 65k+ stars and provides a full set of agent skills plus a software development methodology.

Why do we need Superpowers?

Most AI coding assistants share the same weakness: they rush to write code. When you describe what you want, the model often starts generating implementation immediately—without deeply understanding the real goal, considering design tradeoffs, or ensuring test coverage.

Superpowers is built on a simple idea: think before you code.

It formalizes AI behavior via 14 composable Skills so that the assistant consistently:

1. Design-first — explore requirements and design options before implementation
2. Test-driven — follow a strict RED-GREEN-REFACTOR TDD loop
3. Systematic debugging — find root causes before fixing symptoms
4. Verification-first — prove success with evidence, not assertions
5. Isolated work — use Git worktrees to keep workspaces clean
6. Frequent review — request and apply code review early and often

Overview of the 14 core skills

• using-superpowers — At the start of any conversation: establishes rules for using skills
• brainstorming — Before writing code: turns vague ideas into a concrete design spec
• writing-plans — After design is confirmed: produces a detailed implementation plan
• subagent-driven-development — While executing a plan: uses subagents to parallelize work
• executing-plans — When a written plan exists: executes the plan in an isolated session
• dispatching-parallel-agents — When tasks are independent: dispatches parallel subagent work
• test-driven-development — When implementing features: enforces the TDD loop
• systematic-debugging — When you hit a bug: guides a root-cause debugging process
• verification-before-completion — Before claiming “done”: requires verification before completion
• requesting-code-review — When you finish a task: requests review in a structured way
• receiving-code-review — When you get review feedback: applies feedback rigorously and safely
• using-git-worktrees — When starting new work: creates isolated dev environments
• finishing-a-development-branch — When wrapping up a branch: guides merge/PR/cleanup decisions
• writing-skills — When creating a new skill: helps write and test skill docs

Tutorial structure

This series contains 10 detailed tutorials, from beginner to advanced:

Getting started

1. Getting started and installation — Install and configure Superpowers across platforms
2. brainstorming: design-first development — Turn vague ideas into clear designs
3. writing-plans: implementation plans you can execute — Create atomic, actionable plans

Core skills

4. test-driven-development: a practical TDD guide — Follow RED-GREEN-REFACTOR strictly
5. systematic-debugging: debug with a root-cause process — A four-phase root-cause workflow
6. using-git-worktrees: isolated development workflows — Parallel work without conflicts

Collaboration and review

7. The complete guide to code review skills — Best practices for requesting and receiving review
8. subagent-driven-development and parallel execution — Multi-agent collaboration patterns

Advanced

9. verification-before-completion and finishing-a-branch — Verification and branch finishing
10. writing-skills: create your own skills — A complete guide to extending the skill library

Who is this series for?

• ✅ New to AI coding — build good collaboration habits early
• ✅ Experienced developers — improve your AI-assisted workflow
• ✅ Tech leads — standardize how a team works with AI
• ✅ Open-source contributors — learn patterns for collaborating on larger projects

Prerequisites

• Comfortable with at least one platform that supports Superpowers (Claude Code, Cursor, Codex, OpenCode)
• Basic Git knowledge
• Basic understanding of TDD (optional; tutorial 4 covers it in depth)

How to use this series

1. Read in order — skills build on each other
2. Practice first — each tutorial includes hands-on examples
3. Go step by step — master core skills (planning, TDD, debugging) before advanced workflows

Release plan

• Tutorials 1–3 (getting started): this week
• Tutorials 4–6 (core skills): next week
• Tutorials 7–10 (collaboration & advanced): the following two weeks

Series navigation:

• → Next: Tutorial 1: Getting started and installation

Repository: github.com/obra/superpowers

Discussion: Share your Superpowers experience or ask questions in the comments!