Superpowers: Professional Development Workflow in Practice with AI Coding Agents

Intermediate Difficulty | Approx. 15 min read | Master professional development workflows for AI coding agents

If you are using AI coding agents like Claude Code, Cursor, or Codex, you have likely encountered this scenario: you ask the AI to write code, and it immediately starts dumping blocks of code without a word; halfway through, you realize the direction is wrong and have to start over; the code is written quickly, but there are no tests, no comments, and certainly no code review.

This is exactly the problem Superpowers solves. It is an open-source workflow framework for AI coding agents. It isn't just another AI tool; it is designed to make your existing AI coding agents more professional. Through a series of composable "Skills," Superpowers ensures the AI thinks before coding, writes tests before implementation, and conducts reviews after completion.

This article was first published in the OpenClaw community (openclaw.ai), providing a detailed guide on the installation and practical use of Superpowers.

Target Audience

Developers with 1-5 years of experience
Users currently using or planning to use AI coding agents like Claude Code, Cursor, or Codex
Teams looking to have AI generate more professional and maintainable code

Core Dependencies and Environment

AI Coding Platform (Choose one):
- Claude Code (Recommended)
- Cursor
- Codex
- OpenCode
- Gemini CLI
Node.js 18+
Git

Project Structure

superpowers/
├── skills/
│   ├── brainstorming/                     # Design Phase: Socratic Methodology
│   ├── writing-plans/                     # Planning Phase: Task Breakdown
│   ├── subagent-driven-development/        # Execution Phase: Sub-agent Development
│   ├── test-driven-development/            # TDD Cycle
│   ├── requesting-code-review/            # Code Review
│   ├── systematic-debugging/               # Debugging Methodology
│   ├── using-git-worktrees/                # Parallel Development with Git Worktrees
│   ├── finishing-a-development-branch/     # Branch Finalization Workflow
│   ├── dispatching-parallel-agents/        # Parallel Sub-agents
│   ├── receiving-code-review/              # Responding to Code Review
│   └── executing-plans/                    # Batch Plan Execution
├── hooks/                                 # Automation Trigger Hooks
├── .claude-plugin/                        # Claude Code Plugin Config
└── .codex/                                # Codex Config

Step-by-Step Instructions

1. Installing Superpowers

Installation methods vary slightly by platform. We will use the most common one, Claude Code, as an example.

First, add the official plugin marketplace:

/plugin marketplace add obra/superpowers-marketplace

Then install the Superpowers plugin:

/plugin install superpowers@superpowers-marketplace

TIP

If you are using the official Claude Code marketplace, you can also run:

/plugin install superpowers@claude-plugins-official

For other platforms:

Cursor:

/add-plugin superpowers

Codex:

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

OpenCode:

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

Gemini CLI:

gemini extensions install https://github.com/obra/superpowers

Once installed, start a new chat window and say something to trigger a skill, such as "Help me plan a user login feature," and Superpowers will automatically activate the brainstorming skill.

2. Triggering Brainstorming: Let the AI clarify what you want first

This is the core philosophy of Superpowers: AI should not jump into coding immediately; it must first understand what you want to achieve.

When you express an idea, Superpowers automatically triggers the brainstorming skill. It won't start writing code right away. Instead, it uses the Socratic method—clarifying your requirements through a series of questions.

For example, if you say "Help me build a user management system," Superpowers might respond like this:

I need to understand your specific requirements first:

What features should the user management system support? (Registration, login, permissions, OAuth...)

Who is the target user? An internal system or public-facing?

Are there existing tech stacks that need integration?

What are the performance requirements? How many expected users?

Please provide more details so we can define the "what" clearly first.

This phase continues until you and the AI reach a consensus. Superpowers will then organize the discussion into a design document and present it in chunks for your confirmation.

3. Design Document Confirmation: Chunked Presentation

After you answer the questions, Superpowers generates a structured design document. However, it doesn't show it all at once; it presents it in chunks, allowing you to confirm section by section.

Documents typically include:

Overview: What problem the system solves
Feature List: Specific functionalities to implement
Technical Solution: Tech stack and architectural design
Data Model: Database/data structure design
API Design: Interface definitions
Non-functional Requirements: Performance, security, scalability

After showing each chunk, it will ask, "Does this look good?" or "Is there anything that needs adjustment?" It only proceeds to the next section after your confirmation.

WARNING

Be sure to review the design document carefully! Modifying the design at this stage is the cheapest. Once you enter the development phase, the cost of changing requirements increases exponentially.

4. Automatic Plan Generation: Creating an Executable Task List

Once the design document is confirmed, Superpowers triggers the writing-plans skill to generate a detailed implementation plan.

This plan is characterized by being extremely granular:

Each task can be completed in 2-5 minutes
Each task has precise file paths
Each task includes complete code examples
Each task has verification steps

The plan looks something like this:

## Task 1: Create User Table
- File: src/db/schema.ts
- Verification: Run `pnpm db:generate` with no errors
- Time: ~3 minutes

## Task 2: Implement User Registration API
- File: src/app/api/users/register.ts
- Verification: curl test returns 201
- Time: ~5 minutes

## Task 3: Implement User Login API
- File: src/app/api/users/login.ts
- Verification: curl test returns token
- Time: ~5 minutes

...

5. Sub-agent Execution: AI Works Autonomously

When you say "Start," Superpowers initiates the subagent-driven-development skill.

This skill creates an independent sub-agent for each task. The sub-agent's workflow is:

Read Task: Understand exactly what needs to be done
Write Test First: Follow TDD principles, writing a failing test first
Implement Code: Write the minimum code to make the test pass
Code Review: Check if the code meets standards
Submit Result: Task completed

TIP

You can have Superpowers pause after every few tasks so you can ensure the direction is correct. This maintains development momentum without losing control.

One powerful aspect of Superpowers is its two-stage review:

Stage 1: Check if it conforms to the plan specifications
Stage 2: Check code quality (readability, performance, security, etc.)

Only after passing the review will the sub-agent proceed to the next task.

6. Forced TDD: The Red/Green/Refactor Cycle

Superpowers' test-driven-development skill enforces the TDD process:

RED: Write a failing test first
GREEN: Write the minimum code to pass the test
REFACTOR: Refactor the code while ensuring tests still pass

If the AI attempts to write implementation code before tests, Superpowers will block it and demand a return to the TDD flow.

// Example: Implementing an addition function
// Step 1: Write test (RED)
describe('add', () => {
  it('should add two numbers', () => {
    expect(add(1, 2)).toBe(3);  // add function doesn't exist yet, test fails
  });
});

// Step 2: Write minimum code to pass (GREEN)
function add(a: number, b: number): number {
  return a + b;
}

// Step 3: Refactor if necessary
// While ensuring the test still passes

7. Code Review: Automated Checks Upon Completion

When a task is finished, Superpowers triggers the requesting-code-review skill.

The review checklist includes:

Functional Completeness: Are all planned features implemented?
Code Correctness: Is the logic sound? Are edge cases handled?
Code Quality: Is naming clear? Are functions too long? Is there duplicate code?
Security: Are there vulnerabilities like SQL injection or XSS?
Performance: Are there obvious performance bottlenecks?

Review findings are categorized by severity:

Critical: Must fix before merging
Major: Strongly recommended to fix
Minor: Suggested improvement

8. Branch Finalization: Merge/PR/Cleanup Options

Once all tasks are complete, Superpowers triggers the finishing-a-development-branch skill, presenting several options:

Merge to Main: Merge directly if all tests pass
Create PR: Create a Pull Request if team review is required
Keep Branch: Keep the branch for further development
Cleanup: Delete the development branch and workspace

It also displays final test results and code coverage metrics to help you make an informed decision.

Troubleshooting

1. What if a skill doesn't trigger automatically?

First, verify that Superpowers is installed correctly:

/plugin list

Ensure superpowers is in the list.

If it still doesn't trigger, try telling the AI explicitly: "Please use the Superpowers brainstorming skill to help me design this feature."

2. How to intervene if a sub-agent gets stuck?

During execution, you can say "pause" or "stop." Superpowers will halt and wait for your instructions.

You can then:

Check current progress
Modify subsequent tasks
Adjust the direction
Resume execution

3. How to enforce the TDD flow if it's skipped?

If you notice the AI wrote implementation code without tests, say:

"Please return to the TDD flow. Delete the implementation code you just wrote and follow the RED-GREEN-REFACTOR sequence."

Superpowers will force the AI to comply.

4. What if the design document is too large?

If the document is very long, Superpowers will automatically chunk it. You can also request:

"Please split this design document into smaller parts and show me one section at a time for confirmation."

5. How to customize skill behavior?

Detailed instructions for each skill are located in their respective SKILL.md files. You can modify these files to adjust behavior.