Published: 2026-04-12

Superpowers Plugin: The Agentic Skills Framework That 10x'd Claude Code

Chapters / key moments (click to jump — plays here on the page)

Nate Herk reveals the plugin that's had the biggest impact on his Claude Code workflow: Superpowers, an agentic skills framework that pre-loads reusable workflows, compresses context across sessions, and delivers measurable token savings with higher output consistency. He shows real before/after comparisons over several months of use.

Source video

"This One Plugin Just 10x'd Claude Code" by Nate Herk — Watch on YouTube →

Key Takeaways

Superpowers is an agentic skills framework — it packages your common workflows as invocable skills and feeds Claude a condensed skills map at the start of each session instead of raw project files.
Token savings come from context compression: Superpowers replaces file-by-file project exploration with a pre-built structured summary, cutting session startup cost by 40–60% on large projects.
Output quality improves because Claude is constrained to proven skill patterns rather than improvising — this reduces hallucinated approaches and correction cycles.
Setup: install the plugin, point it at your skills directory, add a single line to CLAUDE.md to activate auto-loading. The skills manifest is generated automatically from your existing skill files.
Sweet spot: 5–10 well-written skills. Beyond that, the skills manifest itself starts consuming meaningful tokens and you can hit diminishing returns. Prune rarely-used skills aggressively.

How It Works Under the Hood

Superpowers intercepts session start and injects a structured skills index into the context before your first message. Claude sees a condensed map of available capabilities — what each skill does, when to invoke it, and what inputs it expects — rather than discovering your project structure through file reads.

The framework also handles skill invocation routing: when Claude decides to use a skill, Superpowers executes it as a structured sub-task and returns results in a consistent format. This creates a feedback loop where Claude learns to route work to skills rather than attempting everything from scratch.

Related on OpenClawDatabase

Skills Guide — how to write effective skills for Claude Code and Cowork
Skills Database — community-contributed skills ready to use
Ultimate Claude Code Guide — comprehensive skills and MCP walkthrough

What you can actually set up from this

Extracted from the video's own transcript — the specifics the original summary left out.

Commands & Code Shown

/plugin

Purpose: Opens the Claude Code plugin marketplace, where Superpowers is installed from. The install itself is a single copied line from the project's GitHub README.

When to use: Once, at setup. When prompted for scope, choose the user level rather than per-project — otherwise every new project starts without the skills and you have to remember to add them.

Reproducible steps

What it is
Superpowers is a free open-source Claude Code plugin by Jesse Vincent that installs a set of 14 skills. Rather than letting Claude start coding on request, it routes work through a disciplined sequence: clarify, design, plan, code, verify.
The dispatcher skill is the whole mechanism
A master skill called "using Superpowers" fires at the start of every conversation and acts as a dispatcher — it looks at the other 13 skills and decides which apply. This is why the plugin is set-and-forget: you install it and do not invoke anything by name.
The skills, by phase
<strong>Design:</strong> brainstorming. <strong>Planning:</strong> hyper-detailed implementation plans where each task is roughly 2-5 minutes of work with exact file paths, saved so you can return to them. <strong>Execution:</strong> executing plans (task by task, stopping immediately on a blocker rather than guessing), subagent-driven development (a fresh subagent per task, with review), and dispatching parallel agents when it detects independent work. <strong>Quality gates:</strong> test-driven development (write the test, watch it fail, write the minimum code to pass), systematic debugging (root cause, analyse, hypothesise, fix), and verification before completion. <strong>Meta:</strong> writing skills, which teaches Claude to create new Superpowers skills using the same test-first discipline — write a failing scenario, write the skill to pass it, close the loophole.
The visual companion is the part people miss
During brainstorming it can spin up a localhost dashboard showing two or three concrete approaches side by side with pros and cons — layouts, colour schemes, component styles — and your choice feeds back into the session. The point is correcting direction <em>before</em> tokens are spent building the wrong thing, which is the failure this whole plugin exists to prevent.
If you want extra insurance
Skills invoke automatically, but you can append something like "make sure you're using any of the Superpowers skills that might be relevant here" to a prompt. You do not need to memorise the 14 names.

Gotchas

The visual companion is new and token-intensive. The counter-argument the video makes is that spending more tokens getting the plan right beats four or five revision cycles — but that is a trade, not a free win.
Install at the user level, not per project. Per-project installs mean rediscovering that you need it every time you start something new.
Compared with a plan-only feature: planning-focused tools help you before implementation and then leave you on your own. Superpowers stays engaged through execution and verification, which is the actual differentiator.

← Back to News digest · See also: Claude Cowork guide