obra/superpowers: A Hands-On Guide to the Agentic Skills Framework

Agentic skills framework — interconnected capability nodes

On April 11, 2026, obra/superpowers picked up 1,589 GitHub stars in a single day — placing it second on GitHub Trending behind only multica, and making it part of the same 7-repo agentic ecosystem surge that dominated developer conversation this week. It now has over 147,000 total stars since Jesse Vincent first published it in October 2025.

The star count is the least interesting thing about it.

Superpowers fills a gap that wasn’t obvious until it was filled: the space between “raw Claude Code prompts” and “structured, repeatable, professional-grade development workflow.” It’s not a harness builder like Archon. It’s not a managed platform like multica. It’s a methodology enforcer — a set of composable skills that teach Claude Code to behave like a senior engineer before it writes a single line of code.

This guide covers what Superpowers actually is, how it works mechanically, how to install it, when it makes sense over alternatives, and what the 147k-star trajectory tells you about where agentic development tooling is heading.

What Superpowers Actually Is

Jesse Vincent built Superpowers to solve a problem he encountered while building Request Tracker — the open-source ticketing system used by thousands of organizations worldwide. When he started using Claude Code in late 2025, the same pattern kept emerging: Claude would jump to implementation before understanding the problem, skip tests, and produce code that was technically correct but architecturally wrong.

His October 2025 blog post describes the insight: the issue wasn’t Claude’s capability. It was the absence of a professional development process. Superpowers is that process, encoded as skills.

The framework defines a seven-phase development workflow that activates automatically:

Brainstorming — Before any code is written, the agent explores your codebase, asks clarifying questions, identifies edge cases, and refines what you’re actually trying to build.
Git Worktrees — Creates isolated development branches with clean test baselines. No cross-contamination between feature work.
Planning — Breaks the work into 2–5 minute tasks with exact specifications. Not a bullet list — a real engineering plan.
Execution — Dispatches subagents per task with two-stage review. Parallel where safe, sequential where not.
Testing — Enforces test-first development. Code written before tests? Deleted. Start from the test specification.
Code Review — Reviews work against the plan with the adversarial lens of a senior engineer. Blocks on critical issues before merge.
Finalization — Verifies tests, manages merge decisions, creates a clean history.

The key word in the README is “automatically.” Skills activate based on context. You don’t prompt them. Your agent just behaves differently.

Design philosophy: The goal is workflows “clear enough for an enthusiastic junior engineer with poor taste, no judgement, no project context, and an aversion to testing to follow.” That constraint — making the process legible even to a bad junior engineer — is what makes it reliable at scale.

How to Install Superpowers in Claude Code

Installation is two commands in Claude Code:

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

After setup, a ~/.config/superpowers/ directory initializes with Git version control. This means your skill configuration is versioned, shareable across machines, and can be customized per-project.

For Cursor, use the built-in plugin search. For Codex/OpenCode and Gemini CLI, there are manual setup URLs in the README. Superpowers is one of the few Claude Code frameworks that supports all four major AI coding environments.

Superpowers was accepted into the official Anthropic Claude Code plugin marketplace on January 15, 2026 — one of the first community projects to receive Anthropic’s endorsement. That acceptance means the skill format and methodology are compatible with Anthropic’s plugin spec, and you can install it without adding custom marketplace URLs.

The full workflow activates on the next development task you start in Claude Code. You’ll notice the difference immediately: instead of Claude jumping to code, it asks what you’re actually trying to build.

The Before/After That Made Developers Switch

Alberto Méndez’s hands-on walkthrough using an email validator project captures the concrete difference:

Without Superpowers:

Claude skips writing tests entirely
Creates ad-hoc solutions without consistent patterns
Makes random debugging changes without systematic diagnosis
Jumps into coding without architectural planning
Produces code that works in demos but breaks in production edge cases

With Superpowers:

Brainstorming phase identifies edge cases (international addresses, + sub-addressing) before any code exists
RED phase writes failing tests that define expectations
GREEN phase implements the minimum code to pass them
REFACTOR phase modularizes validation into separate, testable units
Final deliverable includes automated tests, clean git history, and a demo interface

Evan Schwartz’s rave review puts the outcome plainly: “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.”

The HN reaction surfaced honest limitations too: “I think Claude makes more mistakes when using superpowers than when not” — with the commenter acknowledging this might reflect user approach rather than tool limitation. Another common observation: “At first glance it seems overengineered but once you’re in the flow it makes a lot of sense.”

How Superpowers Differs from Archon, multica, and GSD

The agentic ecosystem has three distinct tool categories right now, and Superpowers fits one of them specifically. Understanding the distinctions prevents the wrong tool for the wrong job.

Superpowers — constrains the development process. It enforces methodology. You’re still running Claude Code locally. Superpowers just ensures Claude follows engineering discipline. This is the right choice when you want better code quality from Claude Code and you’re willing to invest a bit more time per task in exchange for dramatically fewer regressions.

Archon — constrains the execution environment. Archon lets you define development processes as YAML workflows: planning, implementation, validation, code review, PR creation — all deterministic and repeatable. Cole Medin’s framing is precise: “Like what Dockerfiles did for infrastructure and GitHub Actions did for CI/CD — Archon does for AI coding workflows.” Archon is about structural repeatability. Superpowers is about methodological discipline. Different tools, different problems.

multica — managed cloud platform. multica (1,950 stars on Apr 11) is a hosted agentic platform where you define the agent and the platform handles containers, state, credentials, and orchestration. It’s cloud-hosted infrastructure, not a local workflow tool. The right choice when you’re building production-facing automations, not development-time coding assistance.

GSD — constrains the execution context. GSD addresses context rot in long Claude Code sessions by isolating work into atomic tasks with fresh Claude instances and persisting state to disk. As Ewan Mak’s comparison piece notes, these frameworks are actually complementary: Superpowers during builds, GSD managing context health across long sessions.

	Superpowers	Archon	multica	GSD
What it constrains	Development process	Workflow structure	Infrastructure	Session context
Where it runs	Local, Claude Code	Local, any agent	Cloud-hosted	Local
Primary benefit	Code quality + TDD	Deterministic workflows	Managed infra	Context health
Install	Claude Code plugin	Clone + wizard	Platform signup	npm package

See the best open-source AI agent frameworks guide for broader framework coverage.

When NOT to use Superpowers: The seven-phase workflow is powerful but not free. Build speed takes a hit because test-first workflows consume more tokens and time. For quick scripts, one-off utilities, or throwaway experiments, the overhead isn’t justified. Superpowers pays off on code you’re shipping to production — not on everything.

The Skills That Ship With Superpowers

The framework’s library covers three domains:

Testing & Debugging:

test-driven-development — Enforces RED-GREEN-REFACTOR. Deletes code written before tests.
systematic-debugging — Evidence-based root cause analysis before attempting any fix.
verification-before-completion — Requires proof of working before declaring done.

Collaboration & Planning:

brainstorming — Socratic requirement gathering before any implementation.
writing-plans — Concise, readable engineering plans (not multi-page documents).
executing-plans — Parallel subagent dispatch with two-stage review.
dispatching-parallel-agents — Identifies which tasks can run in parallel safely.
code-review — Adversarial review against the plan, not just code inspection.
git-worktrees — Isolated branch creation for clean development environments.
subagent-driven-development — Orchestration pattern for complex, multi-part work.

Meta:

writing-skills — Create new skills in the Superpowers format.
using-superpowers — Reference for how to work within the methodology.

The companion superpowers-lab repo is where community experimental skills live before they’re folded into main — worth watching for what the ecosystem is building toward.

The writing-skills skill is the meta-capability that makes Superpowers extensible. Teams can define org-specific skills that activate automatically for domain-specific workflows — giving you the same “no manual invocation needed” behavior for your engineering processes.

Why 1,589 Stars in One Day Matters

GitHub Trending is a lagging indicator. A repo doesn’t spike because something changed today — it spikes when existing organic growth hits a threshold that triggers algorithmic discovery, which then creates the burst.

obra/superpowers’s trajectory: launched October 2025, crossed 93,000 stars by March 2026, now at 147,000 total. The 1,589 stars gained on April 11 are the latest in a series of daily bursts as more developers discover it through the Claude Code skills ecosystem.

Today’s GitHub Trending had seven simultaneously agentic repos in the top slots — superpowers (#2), multica (#1), claude-code-best-practice (#3), and four others. claude-code-best-practice has 84 documented Claude Code best practices and sits at 32,100 total stars.

This is what ecosystem crystallization looks like. The tools aren’t competing — they’re specializing. multica handles managed cloud execution. Superpowers handles development methodology. claude-code-best-practice handles knowledge curation. cc-switch handles agent switching and CLI management. Each fills a distinct layer.

Block’s Goose agent demonstrated that production AI agents at scale require this kind of layered tooling. Superpowers is the methodology layer — the one that ensures the code Claude Code generates is actually production-grade, not just demo-grade.

What This Framework Tells You About AI Coding’s Direction

Superpowers exists because raw Claude Code, used naively, produces code that’s impressive in demos and brittle in production. The insight that drives the entire framework: capability isn’t the constraint. Structure is.

The same insight is showing up everywhere in the agentic ecosystem right now. multica and Claude Managed Agents both provide execution structure at the infrastructure layer. Archon provides it at the workflow definition layer. Superpowers provides it at the development methodology layer.

A developer who wants to get serious about AI-assisted engineering in 2026 will likely use all three layers: a skills framework to discipline Claude Code’s methodology, a workflow engine to make processes repeatable, and a managed platform to run production automations. These aren’t competing tools — they’re complements.

Start with Superpowers if you write code with Claude Code and you’re tired of regressions. The two-command install takes under a minute. The improvement to output quality shows up immediately.

Already using Claude Code agent frameworks? See cc-switch for managing multiple agent environments, and Block’s Goose agent case study for what production-grade AI coding looks like at team scale.

obra/superpowers: Claude Code Skills Framework Guide