Superpowers — Spec-Driven Development

Claude Code on its own is a powerful terminal AI agent. But the Superpowers ecosystem takes it to a completely different level — transforming Claude Code from a smart autocomplete into a full software development partner with structured methodology, reusable workflows, and domain-specific intelligence.

Superpowers is a collection of skills (plugins) for Claude Code that you install via settings.json. Each skill is a set of slash commands and custom behaviors that encode best practices for specific development tasks — from Test-Driven Development to debugging to writing technical documentation.

What You'll Learn

• What the Superpowers ecosystem is and who maintains it
• How to install Superpowers skills via settings.json
• The key available skills and what each one does
• How to use each skill effectively
• How to write your own basic custom skill
• How enterprise teams standardize Superpowers across developers
• The spec-driven development workflow using combined skills
• Enterprise skills for compliance, security, and governance

What Is the Superpowers Ecosystem?

The Superpowers ecosystem is a community-maintained collection of reusable skills for Claude Code. A "skill" in this context is a settings.json plugin entry that loads a set of slash commands and instructions into Claude Code's context.

When you install a skill, Claude Code gains new /slash commands specific to that skill. For example, installing the TDD skill gives you /tdd-start, /tdd-test, and /tdd-implement commands that enforce test-driven development workflow.

Why this matters: Without Superpowers, every developer has to repeatedly explain their development methodology to Claude Code at the start of each session. With Superpowers, that methodology is baked in — Claude Code knows exactly how you want to work before you type a single prompt.

India Note: The Superpowers ecosystem is open-source and has growing contributions from Indian developers. Check the community repository for India-specific skills, including skills for GST-compliant code patterns, NPCI payment integration, and Bharat-stack (Aadhaar, DigiLocker, ONDC) development.

Installing Superpowers Skills

Skills are installed by adding entries to your Claude Code settings.json file.

Finding the Settings File

macOS/Linux: ~/.claude/settings.json Windows: %APPDATA%\Claude\settings.json

If the file does not exist, create it.

Adding a Skill

{
  "plugins": [
    {
      "name": "brainstorm",
      "path": "./skills/brainstorm/skill.md"
    },
    {
      "name": "tdd",
      "path": "./skills/tdd/skill.md"
    }
  ]
}

Note: Check the official Claude Code documentation for the latest skill template URLs and community repositories.

After editing settings.json, restart Claude Code. The new slash commands will be available immediately.

Installing Multiple Skills at Once

{
  "plugins": [
    { "name": "brainstorm", "url": "..." },
    { "name": "tdd", "url": "..." },
    { "name": "debug", "url": "..." },
    { "name": "write-plan", "url": "..." },
    { "name": "refactor", "url": "..." }
  ]
}

Key Available Skills

Brainstorm Skill

Purpose: Structured ideation and problem decomposition before coding

Commands: /brainstorm [topic], /brainstorm-refine, /brainstorm-select

How it works:

1. You run /brainstorm "how to implement user authentication"
2. Claude generates 5-7 different approaches with pros/cons
3. You run /brainstorm-refine to dig deeper into promising ideas
4. You run /brainstorm-select to commit to an approach and create a plan

Best for: Architecture decisions, complex feature planning, solving tricky bugs

TDD Skill (Test-Driven Development)

Purpose: Enforces writing tests before implementation

Commands: /tdd-start [feature], /tdd-red, /tdd-green, /tdd-refactor

How it works:

1. /tdd-start "user login feature" — Claude writes failing tests first
2. /tdd-red — Confirms tests fail as expected
3. /tdd-green — Claude writes minimum code to make tests pass
4. /tdd-refactor — Claude cleans up the implementation

Best for: Any feature where correctness is critical

Debug Skill

Purpose: Systematic debugging methodology

Commands: /debug [error or symptom], /debug-hypothesis, /debug-test, /debug-fix

How it works:

1. You paste the error and run /debug
2. Claude generates a ranked list of hypotheses (most likely cause first)
3. For each hypothesis, /debug-hypothesis 1 gives specific tests to run
4. /debug-fix implements the fix for the confirmed hypothesis

Best for: Elusive bugs, production incidents, mysterious errors

Write-Plan Skill

Purpose: Creates detailed implementation plans before any code is written

Commands: /write-plan [feature], /write-plan-review, /write-plan-execute

How it works:

1. /write-plan "payment integration with Razorpay" generates a step-by-step implementation plan
2. /write-plan-review runs a critique of the plan
3. /write-plan-execute starts implementing the plan step by step

Best for: Any feature larger than a single function

Refactor Skill

Purpose: Safe, systematic code improvement

Commands: /refactor [file or selection], /refactor-safe, /refactor-validate

How it works:

1. Claude analyzes the code and proposes specific refactoring changes
2. /refactor-safe checks if the refactoring is safe (will not change behavior)
3. Changes are applied incrementally with validation at each step

Writing Your Own Custom Skill

A Superpowers skill is a Markdown file that defines slash commands and their behavior. Here is a simple example — a skill for writing clean React components:

# React Component Skill

This skill helps write clean, consistent React components.

## Commands

### /react-component [name]
Creates a new React component following project conventions:
- TypeScript with proper types
- Tailwind CSS for styling
- Props interface defined separately
- Export at bottom of file
- JSDoc comment at top

### /react-refactor
Reviews the current component and suggests:
- Extract logic to custom hooks
- Simplify JSX
- Improve type definitions
- Add missing accessibility attributes

## Style Guide
- Use function declarations, not arrow functions for components
- Props interface name: [ComponentName]Props
- Import order: React first, then libraries, then local

Save this as react-skill.md and reference it in settings.json:

{
  "plugins": [
    {
      "name": "react",
      "path": "./react-skill.md"
    }
  ]
}

Note: path for local files, url for remote files.

Enterprise Adoption

For individual developers, installing a few skills and trying them out is straightforward. Enterprise teams face a different challenge: how do you standardize Superpowers across 20, 50, or 200 developers so everyone follows the same methodology?

Centralized skill management. Enterprise teams should commit a shared .claude/settings.json to their monorepo. This file references skills stored in a central skills/ directory within the repository. When a developer clones the repo, they automatically get every approved skill — no manual setup required.

Versioned skill files. Treat skills like any other code artifact. Store them in version control, review changes through pull requests, and tag releases. When the platform team updates the TDD skill to enforce a new testing standard, every developer gets the update on their next git pull.

Company-specific skills. Beyond community skills, enterprise teams should create internal skills that encode company-specific conventions. Examples include a skill that enforces your API naming conventions, a skill that generates boilerplate matching your microservice template, or a skill that checks code against your internal style guide before commit.

Onboarding acceleration. New developers joining the team inherit the full skill set immediately. Instead of reading a 50-page coding standards document, they install Claude Code, pull the repo, and the skills teach them the conventions interactively as they write code.

India Note: Indian IT services companies managing multiple client projects can maintain separate skill sets per client — one settings.json per project repository, each tailored to that client's tech stack, compliance requirements, and coding standards.

Spec-Driven Development Workflow

The real power of Superpowers emerges when you chain multiple skills together into a complete spec-driven development cycle. This workflow transforms AI-assisted coding from ad-hoc prompting into a repeatable, auditable process.

The four-skill cycle:

1. Brainstorm — Start every feature by running /brainstorm to explore approaches. The brainstorm skill forces you to consider multiple solutions before committing to one. Output: a selected approach with documented reasoning.

2. Write-Plan — Feed the selected approach into /write-plan to generate a detailed implementation specification. The plan includes file changes, function signatures, data model updates, and test cases. Output: a step-by-step implementation plan that serves as both a spec and a review artifact.

3. TDD — Execute the plan using /tdd-start for each feature. Write tests first based on the plan's test cases, then implement to make them pass. Output: tested, working code with full coverage of the planned functionality.

4. Code-Review — After implementation, use the code-review skill (or a custom review skill) to validate the code against the original plan. Check for drift from the spec, missed edge cases, and style violations. Output: a reviewed, spec-compliant feature ready for merge.

Why this matters for enterprises: Every phase produces a written artifact — brainstorm notes, implementation plan, test results, review comments. These artifacts create an audit trail that satisfies compliance requirements, supports knowledge transfer, and makes post-incident analysis straightforward. Teams using this workflow report fewer production incidents because issues are caught during the plan and review phases rather than in production.

For a deeper look at structuring AI development phases, see the BMAD method guide which provides a complementary Brief-Map-Act-Deploy framework.

Enterprise Skills

Beyond development workflow skills, enterprise teams need skills that address compliance, security, and governance — areas where consistency is non-negotiable.

Compliance checking skill. A skill that runs /compliance-check before every pull request. It verifies that new code follows data handling policies (GDPR, India's DPDP Act), checks for hardcoded secrets, validates that PII is encrypted at rest, and ensures audit logging is in place for sensitive operations.

Security scanning skill. A /security-scan command that reviews code for common vulnerability patterns — SQL injection, XSS, insecure deserialization, missing authentication checks. Unlike standalone SAST tools, this skill understands the project's architecture (from CLAUDE.md) and can flag context-specific risks.

Documentation standards skill. A /doc-check command that ensures every public API endpoint has OpenAPI documentation, every module has a README, and every complex function has inline comments explaining the "why" not the "what." This skill references the company's documentation template and enforces it consistently.

Code governance skill. A /governance-check command that validates architectural boundaries — ensuring frontend code does not import backend modules, that database queries only happen through the repository layer, and that dependency versions match the approved list. This is particularly valuable for large monorepos where architectural drift is a constant risk.

These enterprise skills work alongside the V.A.U.L.T. transformation framework to ensure that AI adoption across the organization maintains quality and compliance standards.

Tips for Using Skills Effectively

Combine skills. Use Write-Plan first, then TDD for implementation, then Debug if things go wrong. The skills work together naturally.

Customize skills for your stack. Fork a skill from the community repository and modify the style guide section to match your project's conventions.

Share your skills. If you build a useful skill, submit it to the community repository. Indian developers building Bharat-stack skills are especially welcome.

Official Resources

• Claude Code GitHub — Official Claude Code repository and skill examples
• Claude Code Documentation — Base Claude Code docs
• Claude Code Settings Reference — settings.json format
• PromptAndSkills Claude Skills — India-contributed Claude Code skills
• Anthropic Discord — Claude Code — Community discussion
• BMAD Method Guide — Complementary AI development methodology
• V.A.U.L.T. Framework — Enterprise AI transformation framework
• Claude Code Tools — Browse Claude Code prompts and skills
• Claude Code Custom Commands — Setting up custom slash commands