How to Use Superpowers SDD to Improve AI Coding Workflows

Aug 17, 2026

A quick note on naming: “Superpowers SDD” is not an official standalone product name — it’s a shorthand for the spec-first, SDD-like way of working that Superpowers applies to AI coding.

Problem

When I ask Claude Code or Codex to “add user login with JWT auth to my API”, the agent often writes code right away, with few or no clarifying questions, little upfront design, and often no tests. For a one-line fix this is fine. For a medium feature in an existing codebase, the agent can drift from my intent, add features I never asked for, skip tests, and produce changes that are painful to review.

The root cause: code is the first step, and there is no contract to check the result against.

This post shows what Superpowers SDD is and how it fixes that by making the agreed design and implementation plan the contract the agent works against.

What Is Superpowers?

Superpowers is an AI coding agent development methodology, not a single tool. It is built from composable skills — brainstorming, design, planning, TDD, debugging, code review — that wrap around agents like Claude Code and Codex.

What Is SDD?

Spec-Driven Development (SDD) means the specification is the primary engineering contract. You write down the requirements and design first; code is derived from and verified against that spec. The agreed design and implementation plan — not the code — become the contract the agent works against.

Is Superpowers Really an SDD Framework?

Not exactly. Superpowers is broader than SDD. It is a full development methodology that applies SDD-like discipline: the agent must produce a design and an implementation plan before writing any code. SDD’s “spec first” principle is embedded in the workflow, but Superpowers also covers planning, TDD, review, and branch finishing.

How the Superpowers Workflow Works

A simplified view of the Superpowers workflow is:

Idea → Brainstorm → Spec/Design → Implementation Plan → subagent-driven-development / executing-plans → TDD → Implementation → Review → Verification

Each stage has a dedicated skill:

brainstorming: activates before code. Refines rough ideas through questions, explores alternatives, presents the design in sections, and saves a design document. This document becomes the spec.
writing-plans: breaks work into bite-sized tasks (2-5 minutes each). Every task has exact file paths, complete code, and verification steps.
subagent-driven-development / executing-plans: dispatches a fresh subagent per task, then reviews each result in two stages — spec compliance, then code quality.
test-driven-development: enforces RED-GREEN-REFACTOR — write a failing test, watch it fail, write minimal code, watch it pass, commit.
requesting-code-review: reviews the work against the plan and reports issues by severity. Critical issues block progress.
finishing-a-development-branch: verifies tests and handles merge or PR.

The core rule of the TDD skill is short and strict:

Production code → test exists and failed first
Otherwise → not TDD

Installing Superpowers

These install commands come from the official README.

Claude Code, official marketplace:

/plugin install superpowers@claude-plugins-official

Claude Code, Superpowers marketplace:

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

Codex CLI:

/plugins    # search for "superpowers" → select "Install Plugin"

A Practical Example

Take a common task: add user login with JWT auth to an existing API.

Normal AI coding — one prompt, code first:

Add user login with JWT auth to my API

With Superpowers, I start the same way but activate the workflow:

Add user login with JWT auth to my API. Use the brainstorming skill first.

Then the agent follows the pipeline:

brainstorming asks clarifying questions: which user model, which framework, where are tokens stored, is there existing auth?
Brainstorming Q&A
```
Agent: Where should the JWT live — JSON response body or HttpOnly cookie?
Me: HttpOnly cookie.
Agent: Do you need a refresh token?
Me: Not for now.
```
These answers are recorded in the design document, so the agent has less room to quietly add features I never asked for — like a refresh-token flow or cookie-based token storage.
It saves a design document. This is now the spec.
writing-plans produces a task list:

Task 1: add User entity and migration
Task 2: add /api/auth/login endpoint (test first)
Task 3: issue and validate JWT tokens
Task 4: protect /api/me route with auth middleware

Each task is implemented with RED-GREEN-REFACTOR: failing test first, then minimal code.
requesting-code-review checks the result against the plan. Critical issues block progress.
Tests pass and the branch is finished.

Superpowers vs Normal AI Coding

	Normal AI coding	Superpowers
First step	Write code	Brainstorm and design
Requirements	Implied by the prompt	Written spec
Tests	Usually skipped	RED-GREEN-REFACTOR required
Review	Read the diff manually	Review against the plan by severity

Superpowers vs Spec Kit / OpenSpec

These are not the same category. Superpowers is closer to development process and execution discipline. GitHub Spec Kit and OpenSpec are closer to spec management and Spec-Driven Development tooling.

	Superpowers	Spec Kit / OpenSpec
Focus	Process and execution discipline	Spec management and SDD
Main output	Design docs, plans, tests, reviewed code	Spec files in a defined format
Role	Orchestrates the whole dev loop	Manages the spec layer

Don’t treat them as interchangeable substitutes.

When Should You Use It?

Use Superpowers for:

Medium-to-large features
Modifications to an existing codebase
Multi-file refactors
Projects with high testing and correctness requirements
Long autonomous coding sessions

Skip it for:

Very small code changes
One-off scripts
Quick prototypes

The ceremony costs more than it saves on trivial tasks. SDD is not mandatory for every request.

Limitations

The full pipeline adds overhead. For a one-line change, brainstorming and planning are overkill.
It is not a spec-format tool, so it does not replace Spec Kit or OpenSpec for spec management.
The workflow only helps if the agent and the human actually follow it.

Summary

In this post, I explained what Superpowers SDD is and how it turns plain prompt-to-code AI coding into a brainstorm → spec → plan → TDD → review workflow. The key point is that the agreed design and implementation plan become the contract the agent works against, and code is no longer the first step. Superpowers does not make the model smarter — it makes the coding agent behave like a developer who follows an engineering workflow.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

👨‍💻 obra/superpowers on GitHub
👨‍💻 GitHub Spec Kit
👨‍💻 OpenSpec

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!