Skip to content
Back to articles
superpowersclaude-codespec-driven-developmentai-coding

Decoding Superpowers: the most popular AI coding workflow framework on GitHub

Superpowers, Spec Kit, or GSD? Learn what an AI coding workflow framework is, compare the top 3, and use Superpowers in a real web app.

11 min read

Decoding Superpowers: the most popular AI coding workflow framework on GitHub

Why these AI coding workflow frameworks have become the new normal for serious Claude Code users, and how to start using Superpowers on a real web app.

Context

Working with a coding agent without a method is like hiring a talented engineer and accepting that they will go straight to git push without reviewing anything. It works in demos. It breaks in production.

The shift that has been happening since the second half of 2025 is the rise of workflow frameworks: a discipline layer that installs on top of Claude Code (and similar agents) and forces the agent to brainstorm before coding, write a spec before a plan, a plan before code, and review before marking anything done.

By April 2026, three projects lead the category: Superpowers (171K stars), Spec Kit (91K), and GSD (58K). All three incorporate some form of "spec-driven development" as a central practice (Spec Kit is the most explicit; Superpowers and GSD use it as a layer of the workflow), but solve the broader problem with different vocabulary and mechanics. This article compares them and shows how to run Superpowers, the most popular one, on a real web project.

What is an AI coding workflow framework

An AI coding workflow framework (also called "methodology for coding agents" in technical writing) is, at its core, a set of instructions and gates that you attach to your agent (Claude Code, Cursor, Codex, OpenCode, etc.) to make it follow an engineering process instead of improvising.

The difference between this and a regular prompt is structural:

  • Single prompt: you write "implement feature X". The agent decides everything: scope, design, code, tests, order.
  • Workflow framework: the agent is forced to stop before writing the first line of code. It asks questions. Presents options. Asks for section-by-section approval. Only then enters implementation mode. And even then, it follows a TDD cadence, frequent commits, and review between tasks.

Jesse Vincent, creator of Superpowers, describes the category as "a complete software development workflow for your coding agents, built on top of a set of composable 'skills'". Skills here are markdown files that live in your agent install, describe how to execute a specific capability (brainstorming, writing plans, doing TDD, reviewing code), and activate automatically when the agent recognizes the user's intent.

The category emerged as a reaction to three concrete problems of method-less AI coding:

  1. Vibe coding does not scale. Saying "just ship it" works in scripts. In medium features, the agent loses direction.
  2. Constant replans burn context. Without a spec before the plan, the agent rewrites design mid-implementation and fills the context window with noise.
  3. Lack of gates produces "agentic slop". Without forced brainstorming and mandatory review, the PR comes back full of complexity nobody asked for.

The ecosystem vocabulary (and who uses what)

Each project popularized its own concepts. Knowing the vocabulary helps you understand which tool covers which problem.

Concept Origin What it means
Open source toolkit / product scenarios Spec Kit (GitHub) A set of CLI commands to write specs of "product scenarios" (the "what" and "why") before thinking about stack
Meta-prompting GSD Routing between specialized agents (orchestrator, researcher, planner, executor, verifier) instead of a monolithic prompt
Context engineering GSD Building and maintaining artifacts (PROJECT.md, STATE.md, PLAN.md, etc.) that the agent loads selectively, avoiding "context rot" (quality degradation as the context window fills)
Spec-driven development (SDD) Spec Kit + GSD + Superpowers The written spec is the source of truth; code is generated/regenerated from it
Agentic skills framework Superpowers Skills as composable units: markdown instructions that auto-activate by intent and combine into workflows
Subagent-driven development Superpowers Dispatching a fresh subagent per task, with spec compliance review and quality review between each

Notice the overlap: all three do some form of spec-driven development, but only GSD uses "context engineering" as a central term, and only Superpowers talks about "subagent-driven development" as an execution technique.

The three frameworks side by side

Superpowers Spec Kit GSD
Stars (Apr 2026) 171,494 91,530 58,471
Maintainer Jesse Vincent (obra) Official GitHub TÂCHES
Launched 2025-10-09 2025-08-21 2025-12-14
Tagline "agentic skills framework & software development methodology that works" "open source toolkit that allows you to focus on product scenarios... instead of vibe coding" "meta-prompting, context engineering and spec-driven development system"
Approach Auto-activated skills + subagents with two-stage review Explicit numbered CLI commands (/speckit.specify, /speckit.plan, /speckit.tasks, /speckit.implement) 6-phase workflow per milestone with /gsd-* commands
Platforms Claude Code, Cursor, Codex, OpenCode, Gemini CLI, Copilot CLI 30+ agents (Claude, Gemini, Cursor, Qwen, Tabnine, Kiro, Goose, etc.) 14+ (Claude, OpenCode, Gemini, Codex, Copilot, Cursor, Windsurf, Cline, etc.)
Official marketplace Yes, on Anthropic Claude plugins since 2026-01-15 No (own CLI) No (npx)
Differentiator Modular: you can use a single skill (e.g., just brainstorming) without committing to the whole workflow. Skills auto-activate by intent, no specific commands required. Two-stage subagent review (spec + quality) is a unique mechanism. Explicit numbered commands (/speckit.*) triggered in sequence. "Constitution" (project-governing principles) and an official community extensions ecosystem are Spec Kit's own concepts. Work organized in milestones (not features). Auto-pilot: /gsd-next picks the next phase. Plans are born as structured XML with embedded <verify> and <done> gates inside the spec.

When to pick each:

  • Superpowers if you value modularity and zero ritual: you can install and use a single skill (e.g., just brainstorming) without committing to the whole workflow, and skills fire when the agent recognizes intent, not when you type a specific command.
  • Spec Kit if you prefer explicit numbered commands triggered in sequence (/speckit.specify → /speckit.plan → /speckit.tasks → /speckit.implement). Introduces its own "constitution" concept (project-governing principles) as a first-class artifact and an official community extensions ecosystem.
  • GSD if you organize work in large milestones with an auto-pilot mode: /gsd-next decides the next phase automatically, and plans are born as structured XML with embedded <verify> and <done> gates inside the spec (a stricter format than the markdown the other two use).

How Superpowers works

Technically, Superpowers is a plugin that installs 14 skills in your agent. The main ones:

  • brainstorming: refines ideas through questions before any code.
  • writing-plans: generates an implementation plan with 2-5 minute tasks each, exact paths, complete code, commands with expected output.
  • subagent-driven-development: dispatches one subagent per task, reviews in two stages (spec compliance + quality), and iterates.
  • executing-plans: alternative for platforms without subagent support.
  • test-driven-development: enforces a red-green-refactor cycle on every task.
  • using-git-worktrees: isolates each feature in its own worktree.
  • finishing-a-development-branch: closes the branch via PR or merge.
  • systematic-debugging: when a bug appears, forces root-cause investigation before any fix.

Skills do not run "one at a time" as isolated commands. They compose: starting a feature triggers brainstorming, which after approval calls writing-plans, which after the plan offers subagent-driven-development for execution. You approve at the gates, but the flow between skills is automatic.

The cycle in practice

  1. You say "let's build feature X".
  2. Brainstorming activates. It asks questions (one at a time, multiple choice when possible), presents 2-3 approaches with trade-offs, and proposes a design in sections. Each section needs your approval before proceeding.
  3. The approved design becomes a spec at docs/superpowers/specs/YYYY-MM-DD-<topic>-design.md (default path, configurable).
  4. Writing-plans generates the plan at docs/superpowers/plans/YYYY-MM-DD-<feature>.md. Each task has exact paths, complete code, commands with expected output, no placeholders.
  5. You pick execution: subagent-driven (recommended, fresh subagent per task) or inline (executing-plans).
  6. Subagent-driven-development dispatches the first implementer subagent. It does TDD: writes a failing test, runs it, implements the minimum, makes it pass, commits.
  7. The spec reviewer subagent validates that what was built matches the spec. The code quality reviewer subagent validates quality.
  8. If either rejects, the implementer adjusts and review runs again.
  9. Repeated for every task. At the end, a final code reviewer subagent inspects the full implementation.
  10. Finishing-a-development-branch opens the PR (or merge) with the completed work.

The underlying logic: each subagent starts with a clean context, receives only the text of the task it needs to do plus the curated context from the controller (the main agent). This avoids context pollution and keeps quality stable across hours of autonomous work.

Community reception

The reaction blends practical enthusiasm with informed skepticism.

Most cited praise points:

  • Evan Schwartz, in a personal rave review: "Using Claude Code with Superpowers is so much more productive and the features it builds are so much more correct than with stock Claude Code."
  • Anthropic absorbed Superpowers into the official marketplace on 2026-01-15, an institutional validation.
  • Third-party benchmarks report token reduction and improved cost predictability on medium and complex features, with negligible gain on short tasks.

Criticisms and caveats (Hacker News and other forums):

  • Small tasks suffer from overhead. If you only want to rename a variable, brainstorming is wasted work.
  • "It is the same Claude": Superpowers organizes, but does not fix fundamental limitations of the underlying model.
  • Plan mode in Claude Code itself (not Superpowers specifically) has truncated UX: feedback on the plan forces a full rewrite instead of inline edits.
  • Some argue that separating spec and plan is unnecessary ceremony when the spec is already clear.

Bottom line on reception: the emerging consensus is that Superpowers is gold on medium and complex features (the kind that would naturally take several rounds of rework without a method) and overhead on short tasks. The relative gain is larger for those who improvise a lot; those who already follow a disciplined manual process tend to see smaller wins.

In Practice

Step-by-step to start using Superpowers on a Next.js project (or any web app) with Claude Code.

Prerequisites: Claude Code installed, git repository initialized, working branch other than main.

1. Install Superpowers via the official marketplace

Inside Claude Code, run:

/plugin install superpowers@claude-plugins-official

Restart the session to make sure the skills are loaded.

2. Verify the install

Start a new session and say something that should trigger a skill:

Let's plan the per-post comments feature on the Next.js app.

If Superpowers is active, the agent will not go straight to code. It will respond with something like "I'm using the brainstorming skill to refine this idea" and start asking questions. If instead it generates a React component immediately, the install did not take effect. Check with /plugin list.

3. Let the brainstorming guide you

Answer the questions honestly. The agent is exploring your project and asking about scope, integration with existing auth, data model, and UX. When it presents 2-3 approaches with trade-offs, pick one (do not improvise a fourth option for no reason, that breaks the flow).

When it says "presenting design in sections", read each section and reply "ok" or request changes. Each approval locks that piece.

4. Accept the generated spec

At the end of brainstorming, the agent saves a file like docs/superpowers/specs/2026-04-28-per-post-comments-design.md in your repo. Open it, review it, and accept or request inline changes.

5. Approve the plan

The agent calls writing-plans automatically. The result lands at docs/superpowers/plans/2026-04-28-per-post-comments.md, with numbered tasks. Each task has exact paths, test code, implementation code, the command to run the test, and expected output.

Read it critically. If any task has a placeholder or vague reference, request a fix. Superpowers forbids placeholders in plans precisely because each task ships to a subagent that has no more context than the task text itself.

6. Choose subagent execution

When the agent asks "subagent-driven (recommended) or inline?", pick subagent-driven. Each task becomes a fresh subagent under mandatory TDD.

From there, watch. The agent dispatches the implementer subagent, gets the output, dispatches the spec reviewer, then the code quality reviewer. If either reviewer rejects, the implementer adjusts. At the end of each task, the checkbox in the plan gets marked.

7. Final review and PR

Once all tasks are done, a final code reviewer subagent inspects the full implementation. If approved, the agent calls finishing-a-development-branch and offers to open a PR.

You review the PR like any human work. Approved, merge.

Tip: Do not try to speed things up by skipping brainstorming on medium features. The win is not in the speed of the first iteration; it is in reduced rework. Brainstorming costs 10-20 minutes. It saves hours of "this is not what I wanted".

When to pick Superpowers (and when not to)

Use Superpowers when:

  • The feature has 3+ hours of work or touches multiple files.
  • You are working on production code with existing tests.
  • Recent agent history was full of rework or unnecessary refactor.
  • You want to parallelize features and spend less time coordinating context.

Skip Superpowers when:

  • The task fits in a single small commit (rename, add log, one-line fix).
  • You are prototyping something disposable where "vibe coding" is literally the goal.
  • The underlying model is weak (smaller models can get confused by the framework's complexity).

Final result

What you take from this article:

  • The category is the AI coding workflow framework and exists to fix the three symptoms of method-less AI coding: directionless vibe coding, constant replan, and PRs full of slop.
  • The top three in April 2026 are Superpowers (171K stars), Spec Kit (91K), and GSD (58K). Each popularized its own terms; do not confuse the taglines.
  • Superpowers is the most popular because it integrates auto-activated skills, mandatory TDD, subagent-driven execution, and two-stage review in a single plugin that installs through the official Anthropic marketplace.
  • In practice, installing is a single command. The win shows up on the first medium feature you run with brainstorming + spec + plan + subagent. Not on the 30-line toy example.
  • The method does not replace good code. It replaces the chaos of having no method.

Going further

Picking a workflow framework is half the road. The other half is mastering Claude Code itself: environment setup, supporting tools, prompt patterns, and the habits that separate vibe coding from shipping a finished app.

The Claude Code Course: App Builder (Portuguese) covers exactly that, from zero to a live app: full environment setup, Claude Code supercharged with the best validated tools, frontend, backend, authentication, production deploy, and a professional workflow. Lifetime access, the Claude Code Guide bundled as a bonus, and an unconditional 7-day guarantee.

References