Superpowers: a skills framework for standard software development workflows for AI programming intelligences

Superpowers is open-sourced by developer obra and is designed for AI programming intelligences such as the Claude Superpowers is an underlying skills framework and standard software development workflow tool built by Code, Cursor, Codex, Gemini, and others. Built on mature software engineering methodologies, Superpowers is designed to solve the problems of AI programming assistants being easily sidetracked, lacking in planning, and neglecting testing when faced with complex projects.Superpowers presets a set of highly standardized and combinable “Skills” instruction sets for the AI. When a developer is ready to write code, Superpowers guides the AI through requirements analysis and design validation, then breaks down the task into a very fine-grained execution plan and automates development in strict adherence to the principles of red/green test-driven development (TDD), YAGNI (don't write code you don't need), and DRY (don't repeat yourself). By introducing the “Subagent-driven-development” model, AI automates code writing, self-review and systematic debugging in isolated Git workspaces. Developers only need to make high-dimensional decisions and gatekeepers, and the AI can maintain autonomous and stable operation for a long period of time, significantly improving the efficiency of software development and the quality of code delivery.

Function List

• 🧠 Demand Brainstorming and Socratic Questioning: Automatically activated before code is written. The intelligence will refine the developer's rough ideas by asking questions, exploring alternatives, and presenting the design document in segments for review and saving.
• 🌳 Git workspace management in complete isolation: When a design is approved, isolated Git worktrees are automatically created based on the new branch, running project setups and establishing a clean test baseline, eliminating contaminated trunk code.
• 📋 Extremely Fine-Grained Task Deconstruction and Execution Planning: Precisely break down complex development work into mini-tasks that can be completed in 2 to 5 minutes. Each task is forced to include exact file paths, complete code expectations, and specific test validation steps.
• 🤖 Subagent-driven-development (SDD): Based on the task plan, the system assigns a brand new sub-intelligence to each small task. A two-phase review model is used (checking requirements consistency first, then code specification), supporting batch execution and allowing the setting of human intervention nodes.
• 🧪 Enforcing Test-Driven Development (TDD): Strictly enforce the “red-green-refactor” cycle at the coding stage. Make it mandatory to write test code that will report errors, then write minimal business code that will only allow tests to pass, and automatically clean up any overflow code that is not covered by tests.
• 🔍 Systematic multi-layer code debugging and reviewBuilt-in 4-stage root cause analysis process (including advanced techniques such as defense-in-depth and conditional wait). Code reviews are automatically requested between task nodes, and serious issues will directly block development progress to force a fix.
• 🌿 Fully automated branch closure and cleanup: When all the task lists have been executed, the system automatically reruns the global tests and provides the developer with options for subsequent actions (merging code, committing PRs, keeping or deprecating the branch), and finally automatically cleans up the temporary workspace.

Using Help

Welcome to Superpowers, the underlying skills framework that makes your AI programming assistant a true “advanced software engineer”. rather than providing a graphical interface, the logic of Superpowers works by injecting a set of skills into your AI programming environments (e.g. Claude Code, Cursor) by injecting a set ofMandatory underlying operating law. The efficiency of the 100% can only be realized with an in-depth understanding of its installation logic and operational flow. The following is an extremely detailed guide to its operation and use.

I. Core installation process (multi-platform support)

Superpowers supports the major AI programming tools, and the installation process varies depending on the platform you are using:

1. Installation in Claude Code (recommended)
If you are using the official Claude Code Command line tool that can be installed directly via the built-in plugin marketplace:

• Official Marketplace Quick Install: Run it in the terminal /plugin install superpowers@claude-plugins-official。
• Third-party marketplace installations: If the official marketplace has not been updated with the latest version, you can register for obra's exclusive marketplace first:/plugin marketplace add obra/superpowers-marketplace, and then performs the installation:/plugin install superpowers@superpowers-marketplace。

2. Installation in Cursor
Cursor Also has a built-in plug-in system.

• Open the Cursor Editor to bring up the Cursor Agent dialog box.
• importation /add-plugin superpowers。
• Or just search for “superpowers” in Cursor's plugin marketplace and install it.

3. Installation in the Gemini CLI

• Run the extended install command in a terminal:gemini extensions install https://github.com/obra/superpowers
• If updates are needed, run:gemini extensions update superpowers

4. Manual configuration in Codex or OpenCode
For this type of text-only or command-driven model, you need to give it permission to read Superpowers rules at the beginning of the dialog.

• Codex: Type in the dialog box Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.codex/INSTALL.md
• OpenCode: Input Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.opencode/INSTALL.md

How do I verify that the installation was successful?
Start a brand new session and type directly to the AI: “Help me plan this feature” or “Let's debug this issue Let's debug this issue”. If the AI doesn't start writing code right away and starts asking detailed questions about your needs, Superpowers' brainstorming(Brainstorming) The skill has successfully taken over the conversation automatically.

II. Standardized workflow operational guide

Once you have installed and stated your requirements to the AI (e.g. “I want to develop a user login module”), Superpowers will force the AI to follow these 6 standard stages.Note that at each critical point, the AI stops and waits for your command (usually to say “go” or “yes”)。

Stage 1: Requirements Brainstorming

• operating performance: AI will never output code directly. It will disguise itself as a product manager, digging into the real purpose behind your needs through a succession of Socratic questions. It may ask: “What level of encryption is required for user passwords?” “Is there a lockout limit on the number of failed login attempts?”
• Your operation: Answer AI's questions patiently. If you're not sure about some technical detail, you can just reply with “You suggest the best option”.
• Confirmation of results: When the AI has gathered enough information, it will present a chunked copy of theSystem Design DocumentationYou need to read and reply to “Confirm Design”. You need to read and reply to "Confirm Design, Continue".

Stage 2: Using Git Worktrees

• operating performance: Once the design is approved, the AI automatically invokes the command-line operation Git, which doesn't mess with your current master branch (Main/Master), but automatically creates a brand new branch (e.g. feature/user-login) and an isolated Git working directory.
• Your operationNo need to manually intervene, just wait for the AI to print out the “test baseline cleanup complete” message at the endpoint. This ensures that even if the code is obsolete, it can be discarded at any time with a single click, without messing up your main project.

Stage 3: Writing Writing Plans

• operating performanceAI generates an exhaustive list of tasks based on the design documents, and Superpowers forces these tasks to be broken down to a granularity of “2 to 5 minutes to complete”. For example, instead of writing “Write login back-end logic”, it would write “Write login logic in the /src/auth/ Create password_hash.test.ts Documentation.”
• Your operation: Review this plan carefully. It's like bringing in a new employee: the plan is detailed enough so that the execution doesn't go off the rails. If there are no problems, speak to the AI:“Go”(Start of execution).

Stage 4: Sub-Intelligence Parallel Development & TDD Test Driven (Execution & TDD)

• operating performance: This is Superpowers“ central moment of magic. The system assigns a ”separate sub-intelligence" to each item on the task list.
  • TDD forced intervention: Intelligentsia are forced to write a test case that reports an error (red light) before writing a specific function.
  • It will then write the leanest code possible to get the test to run (green light).
  • If there is any redundant code that has not been tested and verified, Superpowers automatically removes it.
• Your operationThe AI is capable of working autonomously for hours. You can watch it on the terminal screen as it builds files, runs tests, reports errors, fixes itself, passes tests, and commits.

Stage 5: Internal Code Review Mechanism (Requesting Code Review)

• operating performanceWhen several small, related tasks are completed, the AI triggers the requesting-code-review Skill. It compares itself to the just-written code with the plan laid out in Stage 3. If it finds serious bugs or deviations from the specification, the process is automatically blocked.
• Your operation: If the AI encounters an underlying conflict that it can't fix automatically, it will pop up a dialog asking you to do so. In this case, you can point out the modification in the dialog box, for example, “Please use connection pooling mode for the database call here”.The AI receives the feedback (receiving-code-review), will continue to make fixes.

Stage 6: Branch Closing and Delivery (Finishing a Development Branch)

• operating performance: All task lists are checked off and all test cases show 100% Pass. the AI will give you a final report.
• Your operation: AI will provide several options for you to choose from:
  1. Merge directly into the master branch (Merge)
  2. Commit a Pull Request (PR) on GitHub/GitLab
  3. Keep the branch for now and decide later
  4. Deprecate current code
     When you choose to merge, Superpowers automatically cleans up your temporary Git workspace and closes the loop on seamless, clean, standard software development.

III. Advanced tips and considerations

• Skip the tedious steps: If you're fixing a very small and clear spelling mistake and don't want to go through the brainstorming process, you can explicitly give a strong command in the prompt: “Skip the brainstorming skill and go straight to the change! index.html typos in and submit them.”
• Customized skill writing: If you wish to include special code specification checks for your team. You can do this based on the repository's writing-skills Skill templates, write customized workflows in Markdown files and place them in the project directory for the AI to read. the AI enforces your customized specifications as a first principle.

Through this rigorous methodology, even an inexperienced AI model can be coached by Superpowers into a “senior software engineer” who follows standards and emphasizes test delivery. Be sure to trust and follow the workflow of this system, which will dramatically eliminate the “illusion” of AI-generated code and deliver industry-stable code output.

application scenario

1. Complex MVP Rapid Builds for Indie Developers
   When an independent developer needs to build an MVP from scratch that includes front-end and back-end interactions and databases, Superpowers can help the developer quickly complete a stable delivery of the project prototype by reducing the huge workload to zero through its automated task disassembly and sub-intelligence-driven features and by working autonomously for hours on end.
2. Incremental reconfiguration of legacy systems
   When faced with large, undocumented old projects, it's easy for an AI to modify code that could lead to a chain of bugs, and Superpowers enforces test-driven development (TDD) and Git Worktrees that make it essential for an AI to establish a test baseline before writing refactored code, ensuring safe refactoring without breaking the original functional logic.
3. Systematic Troubleshooting and Debugging of Complex Business Logic
   When deep bugs are hard to reproduce, conventional AI assistants usually just “guess” and fix the code. With Superpowers' built-in 4-phase root-cause Systematic Debugging skill, AI can scientifically and rigorously locate and fix deep logic problems through hardcore troubleshooting techniques such as conditional tracing and log validation.
4. Enforcement of standardized code specifications for teams
   Ensuring consistency in code style and quality is difficult in development teams that involve multiple people (or human-computer collaboration). By configuring Superpowers, all code generated by AI must pass a pre-defined code review mechanism that enforces the YAGNI (no useless code) and DRY (no duplicate code) principles, dramatically reducing the workload of code reviewers.

QA

1. What are Superpowers?
   Superpowers is an open source AI programming intelligences skills framework and development methodology tool. It is not a standalone editor, but is installed as a plugin or core instruction set on platforms such as Claude Code, Cursor, and others, enforcing the addition of standard software engineering specifications such as brainstorming, task disassembly, isolated development, and test-driven (TDD) for AI.
2. What AI programming environments does Superpowers support?
   Currently Superpowers fully supports Claude Code (via the official plugin marketplace), Cursor (via the built-in plugin marketplace), the Gemini CLI, as well as purely directive injection into large language model workflows such as Codex and OpenCode.
3. What if the AI deviates from the plan during the work?
   Since Superpowers forces work to be broken down into 2 to 5 minute micro-tasks and reviewed in stages, the system's internal code review mechanism automatically intercepts and blocks development progress if deviations are detected. In special cases, developers can also manually intervene at human checkpoints between AI execution of each microtask with text commands to correct the deviation.
4. How do I update my installed Superpowers?
   If you are using Claude Code, you can run in the terminal /plugin update superpowers Gemini users can run the gemini extensions update superpowers. The built-in skill tree logic is automatically upgraded when the plugin is updated.
5. Can it really code itself for hours while I'm away from the computer?
   Yes, it is. As long as you have fully confirmed the design scheme with the AI in the early stage of “requirement brainstorming” and reviewed and approved its disassembled task list in the stage of “execution plan”, when you type “go! When you type ”go“, the AI adopts ”sub-intelligence body driven development" to automatically cycle through coding, testing and error correction processes in isolated branches, realizing hours of autonomous work.