Best Claude Code Skills in 2026: A Curated Directory

If you have used Claude Code for more than a week, you have probably hit the wall. The base agent is sharp, but the second your work gets repetitive, you start writing the same context into the same prompts day after day. Skills are how you stop doing that.

Last updated: June 10, 2026. Verify skill format and configuration details against the official Anthropic docs before building production workflows.

Official Sources

Use this article as the curation layer, then verify current skill format and best practices against the primary sources:

A skill is a small folder of markdown and helper scripts that Claude Code loads on demand. The model decides when to pull it in based on a one-line description. You stop reprompting. You start composing. If you have not installed Claude Code yet, start with the Getting Started guide.

The problem in 2026 is that the skills ecosystem has gone from empty to flooded in about six months. There is a lot of noise. This post is a working directory of skills I actually use, organized by category, with install paths and honest notes on what each one is good for. If you want the framing for why skills are eating prompt engineering, read why skills beat prompts for coding agents in 2026 first. For the prompts you still write by hand, our prompt critic will flag the usual failure modes before you paste.

How to read this list

For each skill below you get:

• A one-line description of what it does
• The install command or repo path
• When it is worth loading
• When you should skip it

I am not going to pad this with twenty entries. The point of a skill directory is to filter. Eight to twelve well-chosen skills will cover most of a senior developer's day.

1. Documentation fetcher

What it does: Pulls current docs for any library, framework, or CLI tool before the model answers. Replaces the "let me just guess based on training data" failure mode.

Install:

mkdir -p ~/.claude/skills/find-docs
# Add a SKILL.md that wraps a doc-fetch CLI like ctx7

When to load: Any time you are working with a library that has shipped a major version in the last twelve months. Next.js, Prisma, the Anthropic SDK, and most Vercel tooling have all moved fast enough that training data is unreliable.

When to skip: Pure refactoring inside your own codebase. Adds latency for no benefit.

2. Project rules and config updater

What it does: Edits ~/.claude/settings.json and .claude/settings.local.json safely. Adds permissions, hooks, and env vars without you hand-editing JSON.

Install: Ships with Claude Code as update-config.

When to load: Anytime you say "from now on, every time X happens." That is a hook, not a memory note. The skill knows the difference.

When to skip: One-off settings like theme. Use the /config command.

3. Skill auditor

What it does: Lists every loaded skill, its token cost, and its last-used timestamp. Tells you which skills are burning context for no return.

Install:

git clone https://github.com/<your-skills-repo> ~/.claude/skills
# audit and prune skills ship together

When to load: Once a month. Skills bloat is silent. You will be shocked how many you stopped using.

When to skip: New machines with fewer than ten skills installed.

4. Web research and scraping

What it does: Wraps Firecrawl's search, scrape, map, crawl, and interact endpoints. The model picks the right tool for the job. You stop hand-writing fetch loops.

Install:

# The firecrawl skill bundle covers search, scrape, map, crawl, and interact
# Set FIRECRAWL_API_KEY in your shell

When to load: Any research task that touches the live web. Especially good for competitive analysis, doc archaeology, and pulling structured data out of marketing pages.

When to skip: Pure local-codebase work. The skill list gets noisy.

5. Multi-agent dispatch

What it does: Decomposes a goal into independent sub-tasks and fans them out to multiple agents in parallel. Cuts wall-clock time on research and audits by 3 to 5x.

Install: Available as the swarm and multica-pipeline skills in most curated bundles.

When to load: When you have a task with two or more independent parts. Three sequential searches are slower than three parallel agents. See the agentic dev stack walkthrough for a full example.

When to skip: Strictly sequential work. A migration that has to land in order does not benefit from parallelism.

6. Deploy and infra debug

What it does: Encapsulates a specific deploy target's debugging playbook. Coolify, Vercel, Fly, Railway each have their own failure modes and the skill knows them.

Install:

# Example: a coolify-debug skill that knows about
# pnpm-lock drift, build cache pruning, and queue inspection

When to load: The first time a deploy goes red. The model goes from generic advice to running the actual recovery commands you have written down before.

When to skip: Local dev. Adds nothing until something is actually broken in production.

7. Claude API and SDK builder

What it does: Knows the current Anthropic SDK shape, including prompt caching, extended thinking, batch, files, and citations. Migrates code between Claude model versions automatically.

Install: Ships as claude-api in most curated skills bundles.

When to load: Any file that imports anthropic or @anthropic-ai/sdk. The skill triggers automatically once you have it installed.

When to skip: OpenAI or other-provider SDK code. The skill is provider-specific on purpose.

8. Site QA and improvement loop

What it does: Runs a structured audit of a site or app, writes findings into QA.md, then a sibling skill picks items off that list and fixes them.

Install: Project-local. Lives in .claude/skills/qa and .claude/skills/improve.

When to load: At the start of any session on a site you ship to real users. Catches design drift, dead links, and unused code before they pile up.

When to skip: Throwaway prototypes.

9. Content production for video and blog

What it does: A small bundle that handles research, scripting, blog drafting, distribution, and YouTube production assets for a faceless channel. The same pattern works for any content shop.

Install: Project-local skills under a namespace like devdigest:*.

When to load: When you are operating a content pipeline, not just writing one post. The skill enforces the linking and frontmatter conventions you have already decided on.

When to skip: A single one-off blog post. Just write it.

10. Skill builder

What it does: Generates new skills from a description. Asks the right questions about triggers, scope, and disclosure depth, then writes the SKILL.md and helper files.

Install: A meta-skill that ships in most curated bundles as skill-builder or similar.

When to load: The third time you find yourself reprompting the same context. That is the signal that you have a skill, not a prompt.

When to skip: First-time use. Read what are Claude Code skills first.

Build your own: the five-minute skill

The directory above is a starting point, not a destination. Most of the leverage comes from skills you write for your own workflow. Here is the shortest path.

Step one: notice the repetition. If you are pasting the same three paragraphs of context into Claude Code more than twice a week, you have a skill.

Step two: create the folder.

mkdir -p ~/.claude/skills/my-skill
cd ~/.claude/skills/my-skill

Step three: write SKILL.md. The frontmatter only needs a name and a description. The description is load-bearing because it is what Claude reads to decide whether to pull the skill into context.

---
name: my-skill
description: One sentence that tells Claude when to load this. Be specific about triggers.
---

# My Skill

Body goes here. Progressively disclose: link to deeper docs only when needed.

Step four: keep the body small. Under 500 tokens for the always-loaded portion. Link out to longer reference files that the model can read on demand. The self-improving skills post covers the disclosure pattern in depth.

Step five: test it. Open Claude Code, trigger the situation that should activate the skill, and watch whether it actually loads. If the model does not pick it up, your description is too vague. Rewrite it with concrete triggers like "when the user runs npm test" or "when a file imports stripe."

That is the whole loop. Notice, name, write, test, refine.

New Since This Directory Was Written

Three developments since this post first went up are worth knowing before you build out your skill folder.

The npx skills add installer pattern. Community skills are increasingly distributed as installable packages rather than raw GitHub clones. The pattern - npx skills add <name> - handles the folder scaffolding, wires up the description, and optionally drops an example hook into your settings. It has become the de facto way community maintainers ship skills because it lowers the barrier for non-git-comfortable users while keeping everything as plain files on disk. Expect this pattern to show up in more registry listings through the rest of 2026.

Skills as repo-versioned team infrastructure. The most productive teams have stopped treating skills as personal dotfiles and started checking them into the repo under .agents/skills/. When the skills folder travels with the codebase, every new contributor gets the project's conventions automatically - deploy playbooks, QA loops, content pipelines - without a setup step. It also means skill changes go through pull requests and code review like everything else. If you are on a team shipping more than one product, this is the pattern worth adopting first.

Fable 5 and cost-routing patterns. The Fable 5 release shifted how teams think about which model runs which skill. Not all skill invocations justify frontier-model cost. The emerging pattern - covered in detail in factory AI and Droid model routing - tiers subagents by task complexity: fast cheap models for retrieval and classification, frontier models only for generation and judgment calls. If you are running skills at volume, adding a cost-routing layer to your dispatch skill can meaningfully reduce spend without touching quality.

Roadmap honesty

A few things this directory deliberately does not include yet.

A hosted skills marketplace. I am building one (see Hookyard's tutorial flow for the kind of in-product onboarding I want), but the truth is that for most developers in 2026, a curated GitHub repo plus a sync command is still the right install path. Marketplaces add discovery; they also add abandonware. I would rather link to ten skills I run every day than browse a thousand I do not.

A pricing comparison for skills tools. Skills themselves are free. The agents that run them are not. If you want to see how the underlying tools stack up, the AI coding tools pricing comparison for 2026 and the /compare page are kept current.

Anti-patterns. I am collecting them, but the post is already long. The short version: do not write skills that try to do too many things, do not write skills with vague triggers, and do not write skills that duplicate what a well-named slash command would do better.

Cross-agent skills. Skills officially landed in Codex earlier this year, and the format is converging. For now, write skills for the agent you actually use the most. Portability is improving but is not free yet.

If you want the broader landscape of which agent to run those skills inside, the 10 best AI coding tools in 2026 post is the current reference.

The point

Skills are not a productivity hack. They are the place where your taste, your defaults, and your project conventions live so that you stop typing them. Treat the directory above as a starting kit. Audit it monthly. Delete what you do not use. Write the ones that are missing.

The developers who will get the most out of Claude Code in 2026 are the ones who treat their skill folder like a dotfiles repo: small, opinionated, version-controlled, and always shrinking back toward the things that actually earn their keep.

Frequently Asked Questions

How many Claude Code skills should I install?

Eight to twelve well-chosen skills cover most of a senior developer's day. More than that and you start paying context tax - every loaded skill consumes tokens whether it helps or not. Run a skill audit monthly and delete anything you have not triggered in thirty days.

Where do Claude Code skills live on disk?

Skills live in ~/.claude/skills/ for global skills that apply across all projects, or .claude/skills/ in a project directory for project-specific skills. Each skill is a folder containing at minimum a SKILL.md file with frontmatter (name and description) and body content.

How does Claude Code decide which skill to load?

Claude reads the one-line description in each skill's frontmatter and pattern-matches against your prompt. A vague description like "helps with code" will rarely trigger. A specific description like "when the user runs npm test and tests fail" will trigger reliably. The description is load-bearing.

What is the difference between a skill and a slash command?

Slash commands are explicit - you type /commit and it runs. Skills are implicit - Claude decides to load them based on context. Use slash commands for actions you want to trigger manually. Use skills for context and knowledge you want Claude to pull in automatically when relevant.

Can I use the same skills in Cursor or Codex?

Cursor does not use the Claude Code skills format. Codex adopted a similar skill system in 2026 and the formats are converging, but portability is not seamless yet. For now, write skills for the agent you use most. Cross-agent skill portability is improving but expect some manual conversion.

How do I write a skill that improves itself?

Add a reflection hook that runs after the skill is invoked. The hook prompts Claude to evaluate whether the skill helped, and if not, suggests an edit to the SKILL.md. Store reflections in a learnings file that the skill reads on next load. See the self-improving skills guide for the full pattern.

What makes a skill different from just adding instructions to CLAUDE.md?

CLAUDE.md loads on every prompt. Skills load only when triggered. Put global rules in CLAUDE.md - things like "never commit .env files" or "use TypeScript strict mode." Put domain-specific workflows in skills - things like "how to debug Coolify deploys" or "how to draft a blog post for this site." Skills keep your always-on context lean.

Are there any costs associated with skills?

Skills themselves are free - they are just markdown files on your disk. The cost comes from the agent that runs them. Claude Code bills based on token usage, so skills that load large context will increase your spend. Keep skill bodies under 500 tokens and link to longer reference files that Claude can read on demand.