Claude Code Skills in 2026: 7 Worth Using + How to Install or Create Your Own

Official docs and repository files were rechecked on October 7, 2026. Claude Code was unavailable on the research machine’s PATH, so these examples were source-checked without executing a Claude Code session. Our evidence and testing policy explains that distinction.

What a Claude Code Skill actually is

A skill packages instructions for a repeatable task. The useful unit is a folder: SKILL.md explains the workflow, while optional files supply reference material, scripts, or templates. Anthropic describes this as a way to give an agent procedural knowledge that it can load when needed. Anthropic’s explanation of Agent Skills

Think about reviewing a pull request for your team. Claude may understand TypeScript, but it does not automatically know that your API requires cursor pagination, your accessibility policy forbids unlabeled icon buttons, and your reviewer wants findings grouped by severity. A focused review skill captures that procedure once. Its value comes from decisions and checks that would otherwise be repeated in chat.

Claude Code now treats legacy custom commands and skills as one system: .claude/commands/review.md remains supported, while .claude/skills/review/SKILL.md gives the workflow a folder for supporting files. A slash command is the way you invoke it; that spelling alone does not tell you whether it is a bundled skill or fixed built-in command. Claude Code skills documentation

Skills, plugins, MCP, hooks, subagents, and CLAUDE.md

Choose the mechanism by the problem you need to solve. The following comparison is a practical decision aid, not a ranking.

CLAUDE.md provides instructions Claude reads for the project; keep broadly applicable facts there. MCP gives Claude access to external systems. A skill can explain how to use those tools, but it cannot create a working connection by merely mentioning one. Project memory, MCP connections

Plugins bundle capabilities so people can install and maintain them together. Hooks respond to events, while a subagent handles a delegated task with its own context. These mechanisms can cooperate: a plugin might ship a review skill, a specialist agent, and a check that runs after file edits. Plugins overview, Hooks guide, Subagents

How a skill is discovered and loaded

For local terminal work, project skills live at .claude/skills/<name>/SKILL.md. Personal skills live at ~/.claude/skills/<name>/SKILL.md. Plugin skills come from the enabled plugin and use names such as /plugin-name:skill-name. Choose the repository location when collaborators need the same instructions. Skill locations

Discovery and execution are separate. In the normal case, a short name and description make the skill available for selection. The full instructions load when the skill is invoked. Supporting material is read as required. This progressive loading pattern lets a small procedure point to a large reference library. Agent Skills specification

By default, both you and Claude can invoke a skill. Set disable-model-invocation: true for a workflow you want to initiate yourself. Set user-invocable: false for background guidance that Claude should select but users should not run as a command. These fields govern invocation; they do not make the content a security boundary. Invocation controls

Seven capabilities worth considering

The list deliberately includes three bundled skills and four plugin-provided skills. “Worth using” means each solves a recognizable task; it does not mean every project needs all of them. The documented capability classifications come from the command reference and the individual official skill files linked below.

1. /simplify: clean up a completed change

The current command reference classifies /simplify as a bundled skill. It reviews changed code for cleanup and applies fixes, using parallel review agents. Its focus includes reuse, simplification, efficiency, and abstraction. The docs explicitly direct correctness review to /code-review. Commands reference, Code review guidance

Use it after a narrowly scoped implementation has passed its normal checks. For example, a feature may introduce a second date formatter when the project already has one. Cleanup is valuable, but a visually shorter function is not evidence that edge cases still work. Read the resulting diff and rerun checks affected by the edits.

/simplify

For a payment callback, authorization boundary, or data migration, prioritize behavioral review first. The recommendation here is to treat cleanup as the last improvement pass before human review, rather than a substitute for understanding the change.

2. /debug: investigate Claude Code’s own session problems

/debug enables session debug logging and analyzes the log to investigate runtime issues. If you enable it partway through a session, capture starts from that point; it cannot retroactively create missing events. Commands reference

/debug My MCP connection fails after authentication; inspect the session evidence before proposing changes.

This is useful when the problem concerns Claude Code’s tools, configuration, or session behavior. An exception in your application’s shopping cart usually needs application logs and a reproduction, rather than this command alone. Official troubleshooting also separates installation problems from configuration and runtime problems. Troubleshooting

Make the symptom reproducible: describe what you did, what you expected, and the first observable failure. Ask for the smallest configuration change justified by evidence. Review logs before sharing them, especially when account details, paths, or sensitive workspace information may be present.

3. /batch: split a repeatable migration into independent units

/batch plans a large change, presents the plan for approval, and then delegates independent units to background subagents in isolated worktrees. The current command reference says each worker tests and publishes its change; review those repository actions before approving the plan. Worktrees require a Git repository or a WorktreeCreate hook. Outside Git, that hook-based workflow requires Claude Code v2.1.281 or later. Commands reference

/batch Replace the deprecated Button imports in packages/ui-examples. Keep public props unchanged, group work by example directory, and run each package's existing checks.

This example supplies a boundary, an invariant, and a verification requirement. It is a better candidate than “redesign the whole app,” where every unit may depend on a new shared design system. If two workers need to change the same central file, split that shared change out first.

Parallel execution does not eliminate review. It increases the number of changes and outputs you must reconcile. Use a clean branch, define the intended integration order, and inspect each unit’s checks. Git worktrees isolate files; they do not establish logical independence between changes. Parallel worktree workflow

4. frontend-design: make interface decisions intentional

The official frontend-design skill provides guidance for distinctive visual design, including subject matter, typography, layout, and restraint. It asks the agent to plan, review against the brief, build, and critique. It is supplied by the frontend-design plugin. Official skill file

Give it a concrete brief: who uses the screen, what they need to accomplish, what content is real, and which existing visual rules matter. “Make this premium” leaves too much unresolved. “Build a readable field-service checklist for technicians using a phone outdoors” supplies design constraints with practical consequences.

Use frontend-design to propose an interface direction for our field-service checklist. Prioritize large touch targets, legible status labels, and the existing blue accent. Show the design plan before implementation. Verify keyboard focus and the 360px layout after building.

A good visual direction still needs browser checks. Inspect narrow layouts, actual long content, focus states, contrast, and loading behavior. This skill is useful guidance, not a certification that generated UI is accessible or production ready.

5. skill-development: turn repeated instructions into a focused workflow

The plugin-dev skill-development file covers skill structure, trigger descriptions, supporting resources, and progressive disclosure. It is a skill inside the plugin-dev package, rather than an independent plugin. Official skill-development file

Start from three real requests you repeat. For an editorial workflow, they might be “check these product claims,” “find unsupported testing language,” and “prepare the source ledger.” Then define what successful output contains. A useful skill should make those requests more consistent without turning every writing task into a research audit.

Use skill-development to design an evidence-review skill for product guides. Define positive and negative trigger examples, a compact output format, and references that load only when a product fact needs verification.

Ask for a draft you can read end to end. Remove instructions that do not affect the outcome. Validate against tasks that should trigger it and tasks that should not. A polished description is only a hypothesis about selection until you observe actual behavior.

6. mcp-integration: package a real tool connection

The plugin-dev mcp-integration skill addresses connecting MCP servers to plugins, configuration, authentication, and portable paths. Its job is integration guidance. Installing this skill does not install your private service or authorize access to your data. Official mcp-integration file

Use it when you are building a plugin that needs a specific external tool, such as an internal read-only issue lookup. Define the tool’s minimum inputs and output, where the server runs, and the authentication method before asking for configuration.

Treat examples as a starting point. The current Claude Code MCP documentation deprecates SSE in favor of HTTP where available, while this skill file still contains older SSE-oriented recommendations. Prefer current runtime documentation when guidance disagrees. Current MCP transport documentation

Test denied access, expired credentials, unavailable servers, and empty results. Ask whether the workflow should continue safely without the connection. A successful connection on one developer’s machine is only one case in the integration contract.

7. hook-development: attach checks to the event that needs them

The plugin-dev hook-development skill provides hook patterns, examples, and validation utilities. It can help scaffold event-driven automation, including checks before tool use and reactions afterward. Official hook-development file

Use a hook when repeating a check matters more than hoping Claude remembers a prose instruction. A formatter after an edit is one example. A deterministic validator for an operation is another. Choose the narrow event and matcher that match your intent.

Verify generated configuration against the current hooks reference and plugin component docs. Hook types and event support vary; plugin hooks belong under a top-level hooks key in hooks/hooks.json. The plugin skill contains older examples, so copying its entire schema blindly is unsafe. Hooks reference, Plugin component configuration

One concrete mismatch: the older skill uses $TOOL_INPUT in prompt hooks and asks for plain approve/deny text. Current prompt hooks inject JSON with $ARGUMENTS and require a structured ok response, with reason when ok is false. The older direct event map also needs the current top-level hooks wrapper. Keep handlers small, quote paths, and test allowed and blocked cases. Prompt hook configuration, Response schema, Plugin hooks structure

Install the official plugins

The official marketplace registry currently lists both frontend-design and plugin-dev. Use the full marketplace name to make the source explicit. These commands are entered inside a Claude Code session. Official marketplace registry

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

Interactive installation opens the plugin’s details for review and scope selection. Choose user scope across your projects, local scope for just you in one repository, or project scope to share the enabled setting. Each collaborator still installs the plugin on their machine; shared settings do not download it for them. Read the install summary, apply a reload if requested, and confirm the plugin is enabled. Install and manage plugins

Do not install plugin-dev just to run /simplify, /debug, or /batch. They are bundled. Also do not copy marketplace names from an old tutorial without checking the catalog. The plugin-dev README retains a claude-code-marketplace example; this guide uses the independently checked claude-plugins-official registry.

Optional: Anthropic’s separate skills repository is another marketplace. Adding it is unnecessary for the two installs above. Its example-skills and document-skills packages are separate educational examples whose behavior needs validation in your environment. The following command only adds that optional marketplace. Anthropic skills repository

/plugin marketplace add anthropics/skills

See what is available in your session

Type / to inspect available commands. /skills lists skills and lets you change their visibility to Claude and the command menu; review that setting if an entry is missing. Open /plugin to check installed plugins. Plugin skill names use /plugin-name:skill-name, such as /frontend-design:frontend-design and /plugin-dev:skill-development; custom project skills use /skill-name. Commands reference, Plugin installation verification

/skills
/plugin

If an expected entry is missing, verify the folder and filename, the active plugin’s scope, and any installation error. Check whether you started Claude Code in the intended repository. Avoid installing another copy to compensate for a configuration problem; first establish which copy your session can see.

Create a simple custom project skill

Our original example reviews product claims before publication. It intentionally reports findings without editing, publishing, or contacting anyone. This keeps the first experiment easy to inspect. Save the file at .claude/skills/evidence-review/SKILL.md.

Use a lowercase hyphenated name and a description stating the task and when to use it. Claude Code makes frontmatter fields optional and recommends description; the portable Agent Skills format requires name and description. The sample includes both, but disable-model-invocation is a Claude Code-specific field, so this complete example targets local Claude Code and cannot be uploaded unchanged to claude.ai or the Skills API. Agent Skills specification, Anthropic’s template, Claude Code portability rules

---
name: evidence-review
description: Review a product guide for unsupported product claims and fabricated testing language. Use when asked for an evidence review before publication.
disable-model-invocation: true
---

# Evidence review

Review the draft identified by $ARGUMENTS.

1. Read the draft and its source list. Do not modify files.
2. Extract claims about versions, pricing, installation, or behavior.
3. Match each claim to an accessible primary source.
4. Distinguish sourced facts, author recommendations, and test results.
5. Flag first-person testing claims without an evidence record.
6. Report each issue with its location and a concrete correction.
7. End with unresolved publication blockers. Do not publish anything.

Use columns: Claim | Evidence | Status | Required correction.
If a source cannot be checked, mark the claim Unverified.
Do not infer a successful test from a plausible command.

Invoke the workflow with a draft path or other precise input:

/evidence-review content/my-product-guide.md

The sample grants no tool permissions. Its read-only instructions describe the task; Claude Code permission settings govern tool access. An allowed-tools field preapproves listed tools for the invoking turn rather than restricting the tool pool, so review it before adding one. Skill instructions also do not sandbox plugin hook or server processes; their separate execution scope is covered below. Claude Code permissions, Skill tool grants

Evaluate manual /evidence-review calls on a small fixture with one supported fact, one unsupported version claim, and one invented “we tested” sentence. Expect distinct evidence statuses and concrete corrections. Repeat with a missing source to check the Unverified outcome. Because the sample is manual-only, evaluate automatic triggering only if that configuration later changes; include requests that should and should not trigger it.

Record the Claude Code version, the prompt, the output, and whether the result matched those expectations. This is a suggested evaluation procedure, not a test performed for this article. Keep the fixture free of personal data so another teammate can repeat it.

Organize references, scripts, and assets

Begin with the single SKILL.md file. Add other files only when the workflow needs them. In the layout below, references explain a policy, scripts perform a deterministic operation, and assets hold reusable output material. These folder conventions come from the open specification. Optional skill directories

.claude/skills/evidence-review/
  SKILL.md
  references/
    source-policy.md
  scripts/
    check-links.mjs
  assets/
    review-template.md

This is an extension plan, not a claim that these helper files already exist. If you add them, describe when to read each reference and when to execute each script. Define script dependencies and error messages. A link checker can confirm that a URL responds; it cannot confirm that the page supports the claim.

Keep the workflow’s required instructions near the top. Put rare cases in clearly named references. Avoid a maze where one reference points to four others and the key rule sits in the last file. Anthropic’s authoring guidance emphasizes concise instructions and evaluating skills against representative tasks. Skill authoring best practices

Put each instruction in the right place

Consider a publication repository. “Use npm” belongs in CLAUDE.md because it applies broadly. “Audit this draft’s evidence” belongs in a skill because it is a procedure. “Retrieve the source document from a connected system” needs a tool connection, potentially MCP. “Run a check after each edit” needs a hook. “Investigate a large dependency separately” is a candidate for a subagent.

Avoid copying the same rule into every mechanism. Conflicting versions of a policy are harder to debug than a missing instruction. Keep one authoritative reference, name its owner, and link to it from the workflows that need it. A small amount of duplication for a critical constraint can be reasonable; duplicating a whole manual makes maintenance expensive.

Context costs: optional instructions still have a footprint

Progressive loading saves context, but it does not make a huge catalog free. Enabled plugin descriptions can occupy context even before a skill runs. Once invoked, the workflow and its outputs also occupy space. Use /context to inspect the session rather than guessing from the number of folders. Plugin context footprint, Context and usage guidance

Prefer a specific description, a short main file, and targeted references. Disable extensions that do not help the current project. When an investigation would require many unrelated files, give it a narrow delegated task and request a concise report.

Subagent preloading is a special case: a subagent’s skills field injects the full contents at startup. That is useful when the knowledge is essential, but it changes the assumption that only a small description is present initially. Preloading skills into subagents

Security and maintenance are part of installation

Read the instructions and executable files before installing a skill or plugin. Plugins can run hooks and server processes with your user privileges. Anthropic’s security documentation also explains that those processes run outside Claude Code’s tool sandbox; approving tool calls is not a complete audit of plugin behavior. Plugin security and trust

Review network destinations, credentials, downloads, broad permissions, and external changes. Untrusted skill files and content returned by tools or websites can carry prompt injection that tries to redirect the task or expose data. Review proposed commands and critical-file changes; permission and sandbox controls reduce risk without eliminating it. Keep service permissions narrow and secrets outside committed examples. Claude Code security guidance

Treat updates as software changes. Record the source, the version or commit you reviewed, and the last validation date. Recheck behavior when a dependency or Claude Code changes. An official source provides provenance; it does not eliminate the possibility of stale examples, as the MCP and hook guidance above demonstrates.

A starter setup for four kinds of work

These are editorial recommendations, not measured rankings. Choose a workflow with a result you can inspect, define failure behavior, and make its setup repeatable before expanding it.

Common mistakes that waste time

• Installing a plugin for a capability already bundled with Claude Code.
• Treating /debug as a universal application bug fixer.
• Asking /batch to parallelize work with shared dependencies and no boundaries.
• Writing a description so broad that the skill applies to almost everything.
• Copying old marketplace names or hook examples without checking current docs.
• Mistaking a plausible command, a clean diff, or a good-looking screen for proof.
• Sharing a private token, session log, or customer fixture as a “helpful example.”

The practical recommendation

Use the bundled capabilities when their task fits. Add frontend-design for interface decisions or plugin-dev for extension authoring, then cross-check against the current product reference. Create a custom skill when a real procedure needs a maintained home. Explore the AI Coding & Agents topic.

Pick one repeated task and write down a result you can inspect: a claim table, a reviewed diff, or a configuration that passes its checks. Define failure before adding more extensions. Anthropic’s workflow guidance recommends explicit verification criteria and inspecting evidence. Expand the setup only when a real task exposes a gap. Claude Code best practices

Research basis

The source list records publishers, URLs, access dates, and supported claims, following our editorial policy. Product facts were checked on October 7, 2026. Recommendations and prompts are original guidance; About AI Tech Bench explains the publication’s approach. Repositories and documentation can change, so confirm the active version and installation summary before relying on a workflow.