Obra Superpowers is an agentic skills framework and software development methodology designed to enable AI coding agents to perform complex software development tasks autonomously and systematically. It operates by providing agents with a set of composable "skills" and initial instructions that guide their application throughout the software development lifecycle. The core principle is to empower agents to step back, understand the user's intent, and follow a structured process rather than immediately attempting to write code.

The methodology commences when a coding agent is initiated for a development task. Instead of immediate coding, the agent engages in a brainstorming phase, interacting with the user to refine initial ideas, explore alternatives, and derive a comprehensive specification. This design is presented incrementally for user validation. Upon design sign-off, the agent leverages the writing-plans skill to generate a granular implementation plan. This plan meticulously breaks down the work into small, actionable tasks (typically 2-5 minutes in duration), specifying exact file paths, code snippets, and verification steps for each. Emphasis is placed on true Red-Green Test-Driven Development (TDD), You Aren't Gonna Need It (YAGNI), and Don't Repeat Yourself (DRY) principles.

Subsequently, upon user approval, the system transitions into the subagent-driven-development or executing-plans phase. This involves dispatching fresh subagents for each task outlined in the plan. Each task undergoes a rigorous two-stage review process: first for specification compliance, then for code quality. Alternatively, tasks can be executed in batches with human checkpoints for oversight. The framework aims for significant autonomous operation, allowing agents to work for extended periods without deviation from the pre-approved plan. The activation of skills is automatic, integrated into the agent's workflow.

Key skills and their functionalities within the framework include:

• brainstorming: A Socratic method for design refinement, activating before coding commences to elicit precise specifications and save a design document.
• using-git-worktrees: Activates post-design approval, creating an isolated development workspace on a new Git branch, performing project setup, and verifying a clean test baseline.
• writing-plans: Converts an approved design into bite-sized, executable tasks, each with explicit file paths, complete code, and verification steps.
• subagent-driven-development / executing-plans: Manages the execution of tasks, either by dispatching dedicated subagents for two-stage review (spec compliance, code quality) or by executing tasks in batches with human checkpoints.
• test-driven-development: Enforces the RED-GREEN-REFACTOR cycle during implementation. This mandates writing a failing test, observing its failure, writing minimal code to pass the test, observing its success, and then committing. It includes a reference to testing anti-patterns and explicitly deletes code written without prior test coverage.
• requesting-code-review: Activates between tasks to review agent-generated code against the implementation plan, reporting issues by severity, with critical issues blocking further progress.
• finishing-a-development-branch: Engages upon task completion, verifying all tests, presenting options (merge, pull request, keep branch, discard), and cleaning up the worktree.

Additional specialized skills enhance the framework:

• systematic-debugging: A four-phase root cause process incorporating techniques like root-cause-tracing, defense-in-depth, and condition-based-waiting.
• verification-before-completion: Ensures fixes are genuinely effective.
• dispatching-parallel-agents: Enables concurrent subagent workflows.
• receiving-code-review: Guides agents on responding to feedback.
• writing-skills: A meta-skill providing a best-practices guide for creating and testing new skills, ensuring modularity and adherence to the framework's standards.
• using-superpowers: An introductory skill to the system itself.

The philosophical underpinnings of Superpowers are: Test-Driven Development (write tests first), systematic over ad-hoc approaches (process over guessing), complexity reduction (simplicity as a primary goal), and evidence over claims (verify before declaring success). The framework is implemented as a plugin system for platforms like Claude Code, with manual setup options for Codex and OpenCode, and skills are maintained as modular components within the repository, allowing for community contributions and automatic updates.