The Best Claude Code Skills in 2026

Five skills are worth installing in 2026, and one popular pack is worth installing only in pieces. frontend-design, Superpowers, skill-creator, webapp-testing, and mcp-builder each replace a specific thing you currently do by hand, at a token cost you can measure. gstack is excellent and expensive, so you take the three commands you need and turn the rest off.

Everything below was measured on 2026-09-24 by cloning each repository and counting the characters in every SKILL.md. Token figures are estimates at roughly four characters per token. They are close enough to rank by, not exact.

The shortlist

The two cost columns are the whole story, and most "best skills" lists ignore both. So first, the mechanism.

How a skill actually costs you tokens

A skill is a folder with a SKILL.md file: YAML frontmatter on top, instructions below, and optional scripts or reference files next to it. Claude Code handles the two halves very differently.

The listing loads every session. At startup Claude Code builds a list of every model-invocable skill: its name plus its description (and when_to_use, if set). That is how Claude knows a skill exists and when to reach for it. Per the Claude Code skills docs, each entry is truncated at 1,536 characters, and the whole listing has a budget of 1% of the model's context window. When you exceed it, Claude Code shortens descriptions, dropping text from the skills you invoke least first.

The body loads on invocation, then stays. When Claude (or you, via /skill-name) invokes a skill, the rendered SKILL.md enters the conversation as one message and remains there for every later turn. Claude Code does not re-read it. If the same skill fires again with identical content, you get a short "already loaded" note instead of a second copy.

Compaction carries skills forward, with a cap. When the conversation is summarized, Claude Code re-attaches the most recent invocation of each skill, keeping the first 5,000 tokens of each, with a combined budget of 25,000 tokens across all re-attached skills.

Bundled files cost nothing until read. Scripts, templates, and reference docs inside the skill folder are only pulled into context if Claude opens them. Well-written skills tell Claude to run their scripts as black boxes rather than read them.

So a skill has an always-on cost (description length) and a per-use cost (body length). A skill with a 200-character description and a 9,000-character body is cheap to carry and moderate to use. A pack of 60 skills with tiny descriptions is cheap to carry and very expensive to use. Both matter, for different reasons.

You can check all of this yourself:

/context        # Skills row = listing size after the budget is applied
/doctor         # estimate of the listing's cost and its biggest contributors
/skill-doctor   # suggests skills worth turning off

1. frontend-design

Install

/plugin install frontend-design@claude-plugins-official

What it replaces: the paragraph of "use a distinctive font, no purple gradients, not three centered cards" you paste into every UI request.

Cost: 204-character description (about 50 tokens every session). 9,076-character body (about 2,300 tokens) when it fires.

This is the best ratio on the list. The skill is written as a brief to a design lead, and most of it is concrete, checkable rules rather than vibes. It tells Claude to ground the design in the actual subject matter before choosing anything, to pick typefaces deliberately and keep line lengths under 80 characters, and to avoid the specific tells of generated pages: one accented word in a headline, all-caps labels, decorative numbered markers, fade-and-slide-up on every section. It even names the palettes AI design currently clusters around (the warm cream background with a terracotta accent, the near-black page with one acid-green accent) so Claude can steer away from them.

It also ships inside Anthropic's 12-skill example-skills bundle, but install the standalone plugin. You get the one skill you want and none of the eleven you do not.

Skip it if you never touch UI. It will not fire, but its description still sits in the listing.

2. Superpowers

Install

/plugin install superpowers@claude-plugins-official

Or from its own marketplace, which also carries related plugins:

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

What it replaces: your own discipline. Specifically the brainstorm, plan, implement, test, review sequence you know you should run and skip when you are in a hurry.

Cost: 15 skills with about 2,200 characters of descriptions combined (roughly 550 tokens per session). On top of that, a SessionStart hook injects the full using-superpowers skill (about 3,000 characters, roughly 750 tokens) on startup, /clear, and after compaction. Individual skills range from requesting-code-review at about 700 tokens to subagent-driven-development at about 8,000 and brainstorming at about 4,300.

The mechanism is what makes Superpowers different from a folder of prompts. The session-start injection tells Claude to check for a relevant skill before any task, and the skills chain into each other:

1. brainstorming fires before code is written, asks what you are actually trying to do, and presents the design in short sections.
2. using-git-worktrees creates an isolated branch after you approve the design.
3. writing-plans breaks work into 2 to 5 minute tasks with exact file paths and verification steps.
4. subagent-driven-development dispatches a fresh subagent per task with a review after each, or executing-plans does everything inline with one review at the end (the cheaper option).
5. test-driven-development enforces red, green, refactor, and deletes code written before its test.
6. requesting-code-review and finishing-a-development-branch close it out.

The subagent path is the expensive one, but most of that cost lands in isolated subagent context windows, not yours. If your main session is getting heavy, prefer subagent-driven-development. If you are cost-sensitive and the change is small, executing-plans is the lighter route.

The version measured here is 6.4.1. It also includes diagnosing-superpowers: ask Claude to "figure out what went wrong with superpowers in this session" and it reads the transcript and reports which skill fired or failed to, with line-level evidence. That is the tool to reach for when a skill misfires, rather than guessing.

Skip it if you mostly do quick edits and one-line fixes. Superpowers will brainstorm before a rename. That is by design, and it is the wrong tool for that kind of work.

3. skill-creator

Install

/plugin install skill-creator@claude-plugins-official

What it replaces: writing a SKILL.md, trying it twice, and hoping the description triggers.

Cost: 319-character description (about 80 tokens per session). The body is large: 32,626 characters, about 8,200 tokens. It only fires when you are building or editing a skill, so you pay that rarely.

This is the one skill on the list that makes every other skill better, including your own. It does three things most hand-written skills never get:

• Evals with a baseline. It runs test prompts both with and without the skill in the same turn, drafts assertions while they run, grades the results, and opens a local viewer so you can compare outputs side by side.
• Blind comparison. A comparator agent judges two versions without knowing which is which.
• Description optimization. It generates trigger queries (prompts that should and should not fire the skill), reviews them with you, then runs a loop that rewrites the description to improve triggering.

That last one matters more than it sounds. The description is the only part of a skill Claude sees before deciding to use it. A skill with a great body and a vague description is a skill that never runs. The scripts, grader agents, and viewer all live in the skill folder and cost nothing until used.

If you have never written a skill, start with our first skill walkthrough, then bring in skill-creator to test it.

Skip it if you only consume skills and never write them.

4. webapp-testing

Install. It is only available inside the example-skills bundle. Rather than install all twelve skills, copy the one folder into your personal skills directory:

git clone --depth 1 https://github.com/anthropics/skills.git /tmp/anthropic-skills
cp -r /tmp/anthropic-skills/skills/webapp-testing ~/.claude/skills/

What it replaces: alt-tabbing to the browser to check whether the thing Claude just built actually renders.

Cost: 204-character description (about 50 tokens). 3,575-character body (about 900 tokens). The cheapest skill on this list.

It teaches Claude to write native Python Playwright scripts against your local app, with a decision tree: static HTML gets read directly for selectors, a dynamic app gets the "reconnaissance then action" pattern (navigate, wait for networkidle, screenshot or inspect the DOM, then act on selectors it actually saw). The bundled scripts/with_server.py starts one or more dev servers, waits for their ports, runs your automation, and tears everything down:

python scripts/with_server.py \
  --server "cd backend && python server.py" --port 3000 \
  --server "cd frontend && npm run dev" --port 5173 \
  -- python your_automation.py

The design detail worth copying into your own skills: it explicitly tells Claude to run the helper with --help and not read its source, because the scripts are large and would pollute the context window. That one instruction is why its per-use cost stays under 1,000 tokens.

You need Python and Playwright installed locally. The skill does not install them.

Skip it if you already run the Playwright MCP server (it is in the official marketplace as playwright). They solve the same problem two ways. The MCP gives Claude live browser tools. The skill has Claude write throwaway scripts. Keep one.

5. mcp-builder

Install. Same situation as webapp-testing: it lives in the example-skills bundle, so copy the folder.

cp -r /tmp/anthropic-skills/skills/mcp-builder ~/.claude/skills/

What it replaces: a morning reading the MCP spec and SDK docs before writing a server.

Cost: 277-character description (about 70 tokens). 8,703-character body (about 2,200 tokens), plus four reference files it loads by phase: MCP best practices, a Node guide, a Python guide, and an evaluation guide.

The skill runs four phases: research and planning, implementation, review and test, then evaluations. The evaluation phase is the part people skip and the part that matters. It has Claude write 10 realistic questions an agent should be able to answer using your server, then ships a script to run them. That is how you find out your tool names or descriptions confuse the model before your users do.

The alternative: Anthropic's official marketplace now has mcp-server-dev, a three-skill plugin covering building a server, building an MCP App, and packaging an MCP bundle:

/plugin install mcp-server-dev@claude-plugins-official

It is newer and broader (deployment models, MCP Apps), with about 1,340 characters of descriptions across its three skills. If you build MCP servers regularly, it is the better default. If you build one server a year, mcp-builder is lighter and its evaluation phase alone is worth it.

Skip both if you consume MCP servers but never build them.

6. gstack, selectively

Install

git clone --single-branch --depth 1 https://github.com/garrytan/gstack.git ~/.claude/skills/gstack
cd ~/.claude/skills/gstack && ./setup

Requirements per the README: Claude Code, Git, Bun v1.0 or later, and Node.js on Windows.

What it replaces: an engineering process with named roles. /office-hours and /plan-ceo-review for product thinking, /plan-eng-review for architecture, /review for a pre-landing diff review, /qa to test a staging URL in a real browser, /cso for a security audit, /ship to cut the PR.

Cost: this is where the two-column model matters. The repo contains about 60 SKILL.md files (the README advertises 23 specialists and eight power tools). The descriptions are deliberately terse, about 5,000 characters combined, so the always-on cost is only around 1,300 tokens. The bodies are another matter. /review is about 73,000 characters (roughly 18,000 tokens). /office-hours is about 84,000 (roughly 21,000). /design-review is about 131,000 (roughly 33,000). Each includes a shared preamble that runs a setup script and handles onboarding and telemetry consent.

Invoke three gstack skills in one session and you can add 50,000 tokens to your context. Compaction will only carry the first 5,000 of each forward. That is not a flaw in gstack. It is a pack built to do a lot per invocation. It is also a reason not to treat it as always-on.

The measured version was 1.89.0.0. gstack ships its own meter for this: gstack-context-bill audits an installed skills tree offline and reports the always-on frontmatter cost against the per-invocation cost, with a --budget flag to enforce a ceiling.

How to use it well:

1. Install it, then run /review on a real branch and /qa on a real staging URL. The README's own advice is to stop there and decide.
2. Keep the commands you used. Turn the rest off in skillOverrides (edit it via the /skills menu, which writes .claude/settings.local.json):

{
  "skillOverrides": {
    "design-shotgun": "off",
    "ios-qa": "off",
    "ios-fix": "off",
    "retro": "name-only"
  }
}

"off" hides a skill from Claude and the / menu. "name-only" keeps it listed without its description. "user-invocable-only" keeps it in your / menu but hides it from Claude, which suits heavy skills you only ever run on purpose.

3. Watch what the installer writes. The recommended install prompt tells Claude to add a gstack section to your CLAUDE.md listing every command. CLAUDE.md loads in full on every request, so trim that section to the commands you kept. More on why in CLAUDE.md mastery.

Skip it if you already run Superpowers. See below.

What to skip

The whole example-skills bundle. Twelve skills with about 3,400 characters of descriptions combined. Four of them (frontend-design, skill-creator, webapp-testing, mcp-builder) are on this list. The rest (algorithmic-art, canvas-design, slack-gif-creator, theme-factory, brand-guidelines, internal-comms, doc-coauthoring, web-artifacts-builder) are demonstrations. They are good reading if you want to learn skill patterns. They are dead weight in a coding session's listing.

document-skills, unless you generate Office files. The docx, pdf, pptx, and xlsx skills are the ones behind Claude's own document features, and they are strong. Their descriptions total about 3,000 characters, among the longest per skill in the repo. If your repo never produces a spreadsheet, that is listing budget spent on nothing.

The repo's claude-api skill, unless you build on the API. Its body is about 85,000 characters (roughly 21,000 tokens). When you need it, it is the right reference. When you do not, it is the single largest skill in the repository sitting one misfire away from your context.

Two workflow layers at once. Superpowers and gstack both want to own plan, build, review, and ship. Superpowers does it through automatic triggers, gstack through slash commands. Install both and a request like "add a settings page" has two competing processes that both claim it. The same applies to Superpowers plus the feature-dev plugin. Pick one. Our plugins ranking makes the same call for the plugin-level versions.

Non-coding skills in a coding profile. academy-guide and discernment-nudge in the Anthropic repo each carry descriptions over 1,000 characters. Fine in Claude.ai. Not useful while you are debugging.

Failure modes

The listing overflows and your best skill goes quiet. With enough skills installed, Claude Code shortens descriptions to fit the 1% budget, starting with the ones you invoke least. A skill you use weekly can lose the keywords that make it trigger. If a skill that used to fire has stopped, check /context and /doctor before rewriting it. You can raise the budget with the skillListingBudgetFraction setting, but removing skills you do not use is the better fix.

A heavy skill fires on a light task. Skills load on description match, not on your intent. A vague description on a 20,000-token skill means a simple question can pull the whole body in, where it stays for the rest of the session. Fix the description, or set the skill to user-invocable-only so only you can start it.

Stale guidance after compaction. Only the first 5,000 tokens of each skill survive a compaction, within 25,000 total. For a long skill like subagent-driven-development or any gstack command, the tail of the instructions is gone after the summary. If behavior drifts late in a long session, that is often why. Start a fresh session for the next task, or re-invoke the skill.

Hooks that re-inject. Superpowers uses a SessionStart hook matched on startup, /clear, and compaction, so its bootstrap comes back every time. That is intended, and it is also a cost you pay again after every compaction. Harnesses without a post-compaction hook lose the bootstrap entirely, which is why the Superpowers README tells some users to start a fresh session when skills stop triggering.

Trusting third-party code by default. Skills can ship scripts, and plugins can ship hooks, both of which run with your user permissions. gstack's ./setup builds a browser and installs helpers. Superpowers' brainstorming companion loads a logo from its maintainers' site unless you set SUPERPOWERS_DISABLE_TELEMETRY. Neither is hidden, both are documented, and you should still read what you install. Anthropic's own repo carries a disclaimer that its skills are for demonstration and should be tested in your environment before you rely on them.

The minimum viable set

If you build web apps and want the smallest setup that changes how sessions go:

/plugin install frontend-design@claude-plugins-official
/plugin install superpowers@claude-plugins-official
/plugin install skill-creator@claude-plugins-official
cp -r /tmp/anthropic-skills/skills/webapp-testing ~/.claude/skills/
/reload-plugins

That is about 750 tokens of always-on listing (plus Superpowers' ~750-token session injection) for better UI output, an enforced plan and test loop, a way to test your own skills, and a browser check on localhost. Add mcp-builder the week you build a server. Add gstack's /review and /qa if you prefer slash commands to automatic triggers, and swap out Superpowers when you do.

For how skills fit next to CLAUDE.md, subagents, and hooks, the Claude skills guide covers the underlying model.

Posted by @speedy_devv