The Best Claude Code Skills in 2026

Anthropic's document skills

Start here because these are first-party and they actually work. The official skills repo ships pdf, docx, xlsx, and pptx, the four formats most people need an agent to produce. Ask Claude to "turn this analysis into a board deck" and the pptx skill loads, writes the slides with proper layouts, and hands you a real PowerPoint file instead of a markdown approximation.

Who it's best for: anyone who lives in Office or Google's equivalents and wants the agent to output editable files, not text it expects you to reformat.

Pricing: free. The repo sits at roughly 152K stars. Most skills are Apache 2.0; the four document skills are source-available, meaning you can read and run them but they're shared as reference implementations rather than fully open source.

The standout is how cleanly progressive disclosure works. Per Anthropic's docs, the metadata costs about 100 tokens at startup, the SKILL.md body stays under 5K tokens and only loads when triggered, and bundled scripts run via bash without entering your context. Install all four and pay almost nothing until you use one.

The catch: in Claude Code these are filesystem skills you drop into ~/.claude/skills/, and the document formats lean on Python libraries that need to exist in your environment. The pre-built versions run automatically inside claude.ai and the API, but in the terminal you own the dependencies. Budget ten minutes the first time.

Superpowers

Superpowers is Jesse Vincent's (obra's) answer to a specific frustration: agents write toy-grade code unless you force a process on them. It's not one skill, it's a methodology built from composable ones. The agent brainstorms the approach with you, writes a plan, then implements with test-driven-development, verification-before-completion, and code-review steps baked in.

Who it's best for: longer autonomous sessions where you'd otherwise babysit the agent through a multi-file feature. If you're letting Claude run for an hour, you want this on.

Pricing: free, MIT licensed, around 230K GitHub stars at the time of writing. Install with /plugin marketplace add obra/superpowers-marketplace then /plugin install superpowers.

The standout is the skill list itself: test-driven-development, systematic-debugging, brainstorming, writing-plans, executing-plans, using-git-worktrees, requesting-code-review, and a writing-skills meta-skill for building your own. They activate on context, so TDD kicks in when you implement a feature and the debugging skill triggers when you hit a bug.

Where it falls short: it's opinionated, and on a five-minute throwaway script the plan-then-TDD ceremony is overkill. I disable it for quick edits and turn it back on for anything I'd put in a PR. It pairs naturally with the broader tooling in best AI agents.

frontend-design

Every developer knows the default AI interface look: centered card, purple gradient, three feature boxes, rounded corners everywhere. The frontend-design skill exists to kill that. It pushes Claude to commit to a distinct visual direction before it writes a single line of JSX, so you get something with a point of view instead of the same template you've seen a thousand times.

Who it's best for: anyone shipping a real product UI who can't afford to look like a weekend hackathon. It's one of the most-installed skills of the year, with install counts reported north of 270K.

Pricing: free, part of Anthropic's skills repo. In Claude Code you add it to your skills folder; the skill triggers when you ask for interface or component work.

The standout is the constraint-first approach. Instead of asking for "a clean dashboard" and getting mush, the skill makes the agent pick a concept (editorial, brutalist, dense data tool) and execute it precisely. The output reads like a designer made a decision.

The catch: it shapes aesthetics, not architecture. It won't fix your state management or stop a 4MB bundle, and a strong art director will still out-taste it. Treat it as a starting direction, not a final review.

The Karpathy rules

This one is almost embarrassingly simple, which is why it works. Forrest Chang packaged Andrej Karpathy's public observations about LLM coding failures into a single CLAUDE.md with four rules: think before coding, simplicity first, surgical changes, goal-driven execution. It targets the three ways agents wreck a codebase: silent wrong assumptions, over-engineering, and editing files they were never asked to touch.

Who it's best for: literally everyone running Claude Code. If your agent keeps "helpfully" refactoring code you didn't mention, this is the fix.

Pricing: free, MIT. The numbers are wild. TechTimes reported the personal repo and its organization mirror crossed 220,000 combined stars by May 2026. Install with /plugin marketplace add forrestchang/andrej-karpathy-skills then /plugin install andrej-karpathy-skills@karpathy-skills, or just drop the file in your project root.

The standout is the "surgical changes" rule. It tells the agent to touch only what the task requires, which alone removes a huge category of orthogonal-change bugs where Claude rewrites a working function next to the one you asked about.

Where it falls short: it's guidance, not enforcement. The model can still ignore it under pressure, and four rules won't save a vague prompt. It's a floor, not a ceiling. Pair it with Superpowers for the actual process.

If your team is standardizing how everyone runs these agents, that's the kind of operational decision a Dupple X membership helps with, since the playbooks and tool breakdowns keep pace with a stack that changes every few weeks.

wshobson/agents

When you want range instead of one specialist, wshobson/agents is the pack to install. It's a multi-harness marketplace with, by its own README, 84 plugins, 192 agents, 156 skills, 102 slash commands, and 16 orchestrators for multi-agent coordination. It works natively across Claude Code, Codex CLI, Cursor, and Gemini CLI.

Who it's best for: developers who want domain experts on tap. Need a Python specialist, a security scanner, an infra scaffolder? Install the relevant plugin and the right agent shows up.

Pricing: free, MIT, around 37K stars. Install with /plugin marketplace add wshobson/agents then /plugin install python-development (or any of the 84 plugins).

The standout is that it doesn't flatten everything into a lowest-common-denominator format. Each harness gets native artifacts built for its capabilities, so the Claude Code version actually uses Claude Code features instead of a generic export.

The catch: 156 skills is a lot, and installing the whole thing dumps metadata you may never use. Be selective. Install the two or three plugins matching your stack rather than the entire marketplace. If you're comparing harnesses before you commit, my Claude Code vs Cursor and Codex vs Claude Code breakdowns are the place to start.

systematic-debugging

This ships inside Superpowers but deserves its own entry because it changes the single most frustrating agent behavior: guessing at bugs. Instead of trying random fixes until something passes, systematic-debugging makes Claude form a hypothesis, isolate the cause, test it, and only then change code. It turns the agent from a slot machine into a method.

Who it's best for: anyone debugging anything non-trivial. State bugs, race conditions, "works on my machine" mysteries. The structured approach reportedly saves around 2.5 hours a week in testing, more than almost any other single skill.

Pricing: free as part of Superpowers, so you get it automatically with that install.

The standout is the discipline. When an agent says "let me check that assumption" and actually adds a log line before editing, you've already saved yourself two wrong commits.

Where it falls short: it's slower on bugs you could've fixed in thirty seconds. For a typo or an obvious null check, the full hypothesis loop is friction. It earns its keep on the hard ones, not the easy ones.

The Claude API skill

If you build anything on top of the Claude API itself, this is the one skill I'd never uninstall. The claude-api skill gives Claude up-to-date API reference, SDK documentation, and best practices across eight programming languages. It's bundled with Claude Code and also installable from the skills repo.

Who it's best for: developers writing agents, tool-use integrations, or anything calling Anthropic's models. Model IDs, parameters, streaming, caching, the stuff the base model's training cutoff gets wrong.

Pricing: free and pre-bundled.

The standout is freshness. Models, pricing, and API parameters move fast, and the base model will confidently hand you a deprecated model name. This skill pulls the current reference so your code targets what actually exists today.

The catch: it's narrow by design. It only helps when you're building on the Claude API. For OpenAI or Gemini work, it does nothing, and you'd want their equivalents. I cover the broader buildout in best AI agent frameworks.

Office skills (tfriedel)

Anthropic's document skills are great at creating files. tfriedel's claude-office-skills is the pack I reach for when I need to edit existing ones with real fidelity: tracked changes in Word, live formulas in Excel, slide templates in PowerPoint, PDF form filling.

Who it's best for: people whose work involves modifying documents they were sent, not just generating fresh ones. Contract redlines, financial models, branded decks.

Pricing: free and open source on GitHub.

The standout is the editing depth. Producing a new spreadsheet is easy; preserving an existing workbook's formulas and styling while changing the numbers is the part most tools botch, and this handles it.

The catch: there's real overlap with the official skills, and running both can confuse which one triggers. Pick the official document skills if you mostly create, this pack if you mostly edit.