Superpowers

methodology as code

Superpowers is Jesse Vincent’s (obra) answer to “why does my coding agent keep producing garbage?” the problem isn’t model capability—Claude can write excellent code. the problem is workflow. without structure, agents skip tests, ignore existing architecture, write overly complex solutions, and lack systematic debugging approach.

superpowers encodes software development methodology as executable skills. not suggestions—mandatory workflows that trigger automatically. when you start building something, the brainstorming skill activates and forces specification before code. when implementing, test-driven-development skill enforces red-green-refactor. when debugging, systematic-debugging skill requires root cause analysis before fixes.

the result: coding agents that follow disciplined engineering practices without constant human oversight. you get test-driven development, proper git workflow, code review, and systematic problem-solving—the difference between chaotic prototyping and maintainable production code.

the workflow

superpowers defines complete software development lifecycle as sequential skills:

brainstorming activates before code writing. the agent asks clarifying questions, explores design alternatives, presents specification in digestible chunks. you approve design document before implementation starts. prevents the “agent disappeared for 20 minutes and came back with wrong solution” problem.

using-git-worktrees creates isolated workspace on new branch. runs project setup, verifies clean test baseline. proper version control from the start rather than messy main branch development.

writing-plans breaks approved design into bite-sized tasks (2-5 minutes each). every task includes exact file paths, complete code snippets, and verification steps. plans detailed enough for “enthusiastic junior engineer with poor taste, no judgment, no project context, and aversion to testing” to follow—the planning rigor that makes subagent execution reliable.

subagent-driven-development or executing-plans handles implementation. either dispatches fresh subagent per task with two-stage review (spec compliance check, then code quality review), or executes in batches with human checkpoints. the meta-level: using agents to orchestrate agent work, with quality gates preventing cascading mistakes.

test-driven-development enforces during implementation. write failing test first, watch it fail, write minimal code to pass, watch it pass, commit. code written before tests gets deleted—no exceptions. the discipline that separates working software from “looks like it should work” code.

requesting-code-review runs between tasks. reviews implementation against plan, reports issues by severity. critical issues block progress. automated quality control that catches problems early rather than discovering them during production deployment.

finishing-a-development-branch activates when tasks complete. verifies tests pass, presents options (merge, PR, keep, discard), cleans up worktree. proper completion rather than abandoned branch chaos.

the agent checks for relevant skills before any task. these are mandatory workflows, not helpful suggestions you can ignore.

what’s inside

superpowers includes 20+ battle-tested skills covering testing, debugging, collaboration, and meta-development (writing new skills). key components:

testing methodology: test-driven-development with anti-patterns reference. verification-before-completion ensuring fixes actually work. the practices that create reliable code.

systematic debugging: four-phase root cause process with root-cause-tracing, defense-in-depth, and condition-based-waiting techniques. structured debugging replacing random fix attempts.

collaboration workflows: brainstorming, writing-plans, executing-plans, dispatching-parallel-agents, requesting-code-review, receiving-code-review. the team coordination patterns that scale beyond solo development.

git management: using-git-worktrees for parallel development, finishing-a-development-branch for clean completion. version control discipline automated.

meta-skills: writing-skills (create new skills following best practices), using-superpowers (introduction to the system). the framework that enables extending the framework.

philosophy embedded throughout: test-driven development always, systematic over ad-hoc, complexity reduction as primary goal, evidence over claims. principles enforced through automation rather than relying on discipline.

installation and usage

superpowers works with Claude Code (via plugin marketplace), Codex, and OpenCode—the major Claude-based coding assistants. installation differs by platform but concept remains consistent: load skill library, let skills trigger automatically.

for Claude Code:

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

skills activate contextually. start planning a feature, brainstorming skill triggers. start debugging, systematic-debugging skill loads. the progressive disclosure architecture keeps context efficient—skills load only when relevant, using ~100 tokens for metadata scanning until activated.

commands like /brainstorm, /write-plan, /execute-plan explicitly invoke workflows. but mostly, skills work invisibly—shaping agent behavior through automated workflow enforcement rather than requiring constant user commands.

why it matters

superpowers represents methodology automation. software development best practices exist (TDD, systematic debugging, proper planning) but humans (and agents) skip them under pressure. encoding methodology as automated workflow enforcement makes best practices default rather than aspirational.

the framework proves coding agents become dramatically more effective with structure. not smarter models—better workflow. the difference between “Claude writes code” and “Claude follows professional software development methodology.” turns out methodology matters more than raw code generation capability.

the open-source model enables community extension. developers contribute new skills, adapt workflows for domain-specific requirements, and build on foundation rather than reinventing. the superpowers-skills community repository collects contributions. obra’s superpowers-lab hosts experimental skills testing new techniques.

the limitations

superpowers adds overhead. simple scripts don’t need full TDD workflow and git branching. the framework optimizes for substantial development work—multi-file changes, complex features, production code quality. using it for one-off throwaway scripts is overkill.

learning curve exists. understanding when skills trigger, how they interact, and how to customize for specific projects requires investment. the system works better once internalized. initial adoption feels constraining before benefits become obvious.

opinionated methodology won’t suit everyone. superpowers enforces specific approaches (TDD, particular debugging structure, plan-driven development). teams with different methodologies face friction. the framework works best when your preferences align with obra’s encoded methodology.

the trajectory

superpowers’ success indicates demand for structured agent workflows. developers want coding agents that follow disciplined practices, not just write code faster. methodology automation becomes competitive advantage.

the skills marketplace model (obra maintains core, community contributes additions) tests whether collaborative agent tool development works. if successful, expect proliferation of domain-specific skill libraries—superpowers for web development, for data science, for devops, for security.

competition will emerge. other coding agent platforms will build similar workflow automation. whether superpowers captures market share or proves the concept that others copy, the category validates. structured agent development workflows are valuable enough to build tooling for.

obra’s contribution: proving methodology can be automated and that automation dramatically improves agent output quality. the insight that unlocks next generation of coding agents—not just smarter, but more disciplined.

→ related: claude hub