Claude Code Skills (2026): Complete Guide, Best Skills & How to Create Your Own

Claude Code skills are folders of instructions (and optional scripts) that Claude loads dynamically when a task matches. Put them under ~/.claude/skills/<skill-name>/ with a SKILL.md entry point, or install curated ones from a skills marketplace into the same path. Below: how they work, the best Claude Code skills in 2026, how to create your own, install paths, and practices that keep skills useful instead of noisy.

What are Claude Code skills

A skill is a reusable package the agent can pull in mid-session—not a permanent system prompt dump, and not a full plugin marketplace product. Official framing is simple: folders of instructions and scripts Claude loads when relevant, so you extend the agent without stuffing every workflow into CLAUDE.md.

Plain-language map of nearby terms (first time you hit them in docs, this is what people usually mean):

Concept	Human version	Typical shape
Skill	A playbook the agent loads on demand	Folder + SKILL.md under ~/.claude/skills
Slash command	You type /something to force a workflow	Command registration / prompt stub
Plugin	Broader product packaging (UI, hooks, multiple assets)	Installer unit larger than one skill folder
MCP	Live tools over a protocol (APIs, browsers, DBs)	Server process + tool schemas the agent calls

Skills vs slash commands. A slash command is a deliberate user gesture. A skill is closer to “when this kind of work shows up, load this guidance.” Many skill ecosystems also expose slash-style entry points; the important distinction is on-demand loading vs always-on context.

Skills vs plugins. Plugins are distribution and product units—versioning, multi-file packages, sometimes UI. A skill is the agent-facing content unit. Marketplaces often ship plugins that contain skills.

Skills vs MCP. MCP gives the agent tools (read a ticket, open a page, query a service). Skills give the agent judgment and procedure (how to review a PR, when to run tests, what “done” means). You often want both: MCP for reach, skills for taste.

If you only remember one sentence: CLAUDE.md is house rules; skills are optional specialists.

How skills work under the hood

Mechanically, a Claude Code skill is a directory with at least:

~/.claude/skills/my-skill/
  SKILL.md          # required: frontmatter + instructions
  scripts/          # optional helpers the agent may run
  references/       # optional deeper docs loaded when needed

SKILL.md usually starts with YAML frontmatter (name, description, triggers) and a markdown body the model reads as procedure. Exact frontmatter fields evolve with Claude Code releases—treat the Anthropic Claude Code docs as source of truth for schema names—but the pattern is stable: metadata for discovery, body for execution.

Progressive loading is the design point. Claude does not paste every installed skill into every turn. Discovery metadata (description, when-to-use language) is cheap enough to scan; full bodies and heavy reference files load when the task matches. That is why a good description is not marketing fluff—it is the retrieval key.

When a skill is triggered. Roughly:

1. You install skill folders under ~/.claude/skills (or an agent-compatible skills path).
2. The session can see which skills exist and what they claim to do.
3. On a matching user request (or explicit invoke, depending on product surface), the agent loads the skill body and follows it.
4. Optional scripts run only if the skill’s procedure calls for them and your permission mode allows it.

Do not invent private APIs. If a blog claims “skills call endpoint X,” ignore it unless official docs say so. The portable mental model stays: filesystem package + dynamic load + permissioned tools.

The best Claude Code skills in 2026

“Best” depends on your stack. The SERP is full of “I tried 100 skills” listicles; more useful is a short set you can actually install and judge. Below mixes community-famous patterns (superpowers-style autonomous loops, frontend-design taste packs, official-style skill-creator) with real entries from the SeaWork Hub catalog—each linked to a live detail page.

Browse the full library on the SeaWork Hub. Picks:

1. Code review and quality (code-review-and-quality)

Use when a human or agent change is about to land and you want a multi-axis review (correctness, readability, security, tests)—not a vague “LGTM.” Pair it with your team’s real PR checklist. Install from code-review-and-quality on Hub.

2. Test-driven development (test-driven-development)

For greenfield features and bug fixes where “write tests first” keeps the agent honest. Best when your repo already has a clear test runner and conventions; the skill supplies discipline, not a new framework. See test-driven-development.

3. Frontend UI engineering (frontend-ui-engineering)

When the task is layout, interaction, and production UI quality—not just “make a button.” Useful for agent sessions that otherwise ship functional but ugly interfaces. Detail: frontend-ui-engineering.

4. Security and hardening (security-and-hardening)

Before you trust agent-written auth, uploads, or multi-tenant paths. Skills do not replace a security review; they raise the floor of what the agent checks. Hub page: security-and-hardening.

5. Debugging and error recovery (debugging-and-error-recovery)

When the agent is stuck in symptom-chasing. Prefer skills that force root-cause tracing over random file edits. Catalog: debugging-and-error-recovery.

6. Planning and task breakdown (planning-and-task-breakdown)

For large issues that explode if the agent starts coding on the first message. Use planning skills to get ordered tasks and acceptance criteria before tool spam. planning-and-task-breakdown.

7. Git workflow and versioning (git-workflow-and-versioning)

Commit message hygiene, branch discipline, and PR-shaped history—especially when agents default to giant mixed commits. git-workflow-and-versioning.

8. Caveman (caveman) and token-thrifty variants

Community demand for shorter agent chatter is real. Caveman-style skills trade prose for compressed communication when you care about context budget more than politeness. Example on Hub: caveman.

9. Domain packs (example: Three.js game director)

If your monorepo is a game, design system, or vertical CLI, a domain skill beats a generic “write better code” pack. Hub includes specialized packs such as threejs-game-director—install only if that domain matches your work.

10. Community classics outside any one hub

• skill-creator / official create flows — when you want the agent to draft a skill package for you (see next section).
• superpowers-style autonomous loops — community skill sets that emphasize plan → execute → verify loops; quality varies by author, so read SKILL.md before trusting write access.
• frontend-design taste skills — popular listicle favorites for visual polish; treat as taste seeds, not design systems.

Claude skills examples worth copying structurally (not blindly): single-purpose review skills, TDD skills with explicit red-green-refactor steps, and “stop and ask” skills for high-risk ops. The best Claude Code skills in 2026 share one trait: narrow trigger language and a body short enough to load without drowning the task.

How to create your own skill

Two honest paths:

Path A — skill-creator (agent-assisted)

If your Claude Code install exposes a skill creator flow (official or community skill-creator packages), use it when you already have a workflow you repeat in chat. Prompt pattern:

1. Describe the repeated job in one paragraph.
2. List tools/scripts the agent needs.
3. State when not to use the skill.
4. Ask the creator to emit a folder with SKILL.md + optional scripts.
5. Run one real task, then delete half the prose you do not need.

claude skill creator search intent is mostly this: people want a generator, not a blank markdown file. Generators still need your judgment—auto-written skills over-trigger if the description is too broad.

Path B — hand-written minimum

---
name: pr-smoke
description: Run the project's smoke checks before opening a PR. Use when the user says ready to PR, open a PR, or pre-merge check.
---

# PR smoke

1. Confirm the current branch and dirty files.
2. Run the project's standard test command (read package.json / Makefile; do not invent).
3. Run the formatter or typecheck if the repo documents them.
4. Summarize failures with file:line; do not force-push.
5. If checks pass, propose a short PR title and summary—do not create the PR unless asked.

Save as ~/.claude/skills/pr-smoke/SKILL.md. Keep the description searchable (“when the user says…”) so dynamic loading has something to match. Add scripts only when markdown instructions alone are unreliable.

Claude Code skills best practices for authors: one skill = one job; describe negative triggers (“do not use for design critiques”); prefer repo-relative commands; version the folder in git if the skill is team-shared.

How to install skills

Manual install. Clone or copy a skill folder into ~/.claude/skills/<name>/ so SKILL.md is at the top of that folder. Restart or open a new Claude Code session if the agent does not see new skills immediately (behavior can depend on version). For dual-agent setups, some tools also install under ~/.codex/skills or a shared skills cache—check your agent’s current docs.

From a marketplace UI. If you use SeaWork Hub, install puts the package into local agent skill directories (~/.claude/skills and ~/.codex/skills) without hand-copying tarballs. You still own the filesystem: treat installed skills like code you reviewed. Download the desktop client from /download if you want one-click install and agent control on the same machine.

Skills best practices

When to use a skill vs CLAUDE.md. Put stable project facts in CLAUDE.md (commands, architecture, never-do rules). Put optional procedures in skills (how to run a release checklist, how to review React a11y). If every session needs it, it is not a skill—it is project memory.

Single responsibility. A skill named “engineering excellence” will either never trigger cleanly or always trigger. Split into review, tests, security, and release.

Keep bodies short. Progressive loading helps, but a 4,000-line skill is a book. Link to repo docs; do not paste the monorepo into SKILL.md.

Version and review. Skills can instruct shell commands. Pin sources, prefer known authors, and re-read updates after install the same way you re-read a dependency bump.

Measure by outcomes. A “best” skill is one that reduces retries on real tasks for two weeks—not one that ranks high in a listicle.

Codex users. Skills are not Claude-only as a concept: packaged instructions for coding agents show up across CLIs. Paths and loaders differ; if you run both Claude Code and Codex, prefer dual-compatible packs or install the same folder content into both trees when the format matches. See also install Claude Code and install Codex CLI if you are still setting up the agents themselves. Before scaling up skill-driven sessions, review Claude Code pricing, plans, and token costs.

FAQ

What are Claude Code skills? Folders of instructions (and optional scripts) that Claude Code loads dynamically when a task matches. They extend the agent with reusable procedures without stuffing everything into CLAUDE.md.

Where are Claude Code skills stored? Typically under ~/.claude/skills/<skill-name>/ with a SKILL.md entry file. Marketplace installers may also write Codex-compatible copies under ~/.codex/skills. Confirm the path for your CLI version in official docs if a skill does not appear.

What is the difference between Claude Code skills and plugins? A skill is the agent-facing playbook unit (folder + instructions). A plugin is a broader packaging/distribution unit that may include skills, hooks, or other assets. You can use skills without caring about plugin branding; you rarely want a plugin with no clear skill content.

Do Claude Code skills work with Codex? Many skill packages are plain markdown procedures and work with more than one agent if installed into that agent’s skills path. Claude-specific hooks or APIs will not port. Prefer skills documented for both agents, or install the same folder content into ~/.codex/skills when the format matches.

---

Start with one skill that matches this week’s pain (review, TDD, or security), write the description tightly, and delete anything the agent never uses. Skills compound only when each one stays small.