Claude Code Skills vs. Slash Commands: What Changed

In current versions of Claude Code, skills and custom slash commands are no longer two competing extension systems. Anthropic has merged custom commands into skills. A legacy file in .claude/commands/ and a skill in .claude/skills/<name>/SKILL.md can both create a user-invocable command such as /review.

The useful comparison is now between built-in commands, which run fixed Claude Code behavior, and skills, which load reusable instructions and optional supporting files. MCP servers, hooks, and plugins solve different problems.

What appears in the slash menu?

Type / in Claude Code to open the command menu. It can contain:

• built-in commands supplied by Claude Code;
• bundled Anthropic skills;
• user or project skills;
• legacy custom commands;
• plugin commands and skills; and
• prompts exposed by configured MCP servers.

“Slash command” therefore describes how you invoke an item from the interface. It does not tell you whether the item is fixed application logic, a prompt-based skill, or an MCP prompt.

Built-in commands

Built-in commands control Claude Code itself. Examples include session, model, configuration, and context-management actions such as /help or /compact. Availability can depend on the Claude Code version, platform, or plan.

They are implemented by the product rather than by a Markdown prompt you can edit. Use the / menu or current commands reference instead of relying on a static list, because Anthropic can add, remove, or reclassify commands. For example, some items that look like commands are now bundled skills.

What is a Claude Code skill?

A skill is a reusable set of instructions stored in a SKILL.md file. Claude sees the skill's name and description during discovery, then loads the body when the skill is used. This on-demand loading keeps long procedures and reference material out of the context until they are relevant.

A skill can be invoked explicitly:

/review src/auth.ts

It can also be selected by Claude when its description matches the task, unless the skill's frontmatter restricts model invocation.

Project and user locations

• Project skill: .claude/skills/review/SKILL.md
• User skill: ~/.claude/skills/review/SKILL.md
• Legacy project command: .claude/commands/review.md
• Legacy user command: ~/.claude/commands/review.md

Project skills can be committed to version control for a team. User skills follow one developer across projects. Nested project directories and additional configured skill directories can provide other scopes.

A minimal skill

Create .claude/skills/test-coverage/SKILL.md:

---
name: test-coverage
description: Analyze test gaps for a specified file or directory and propose concrete cases.
---

Analyze $ARGUMENTS.

1. Identify important branches with no test coverage.
2. Propose specific tests with inputs and expected outcomes.
3. Flag risky behavior that needs integration or property-based testing.
4. Do not claim a test passes unless it was run successfully.

Then invoke it with:

/test-coverage src/payments/

Claude Code supports argument substitution and additional skill frontmatter for invocation control, allowed tools, subagent execution, and other advanced behavior. Check the current schema before copying a frontmatter field from an old post.

Skills can include more than one Markdown file

A skill directory can contain reference documents, templates, examples, and executable scripts alongside SKILL.md. The main file tells Claude when and how to use those resources.

This makes a skill better than a legacy one-file command for a substantial workflow:

• a deployment checklist plus environment-specific references;
• code-review instructions plus examples of accepted patterns;
• a document-generation workflow plus a template;
• testing instructions plus a helper script; or
• an API integration guide plus schemas and sample payloads.

A bundled script does not bypass Claude Code permissions. Claude still needs an available tool and approval to execute it under the current settings.

Current comparison

Feature	Built-in slash command	Skill	Legacy custom command
Implementation	Fixed Claude Code behavior	SKILL.md instructions plus optional resources	Single Markdown prompt file
Invocation	User types its slash name	User can type /skill-name; Claude may also load it when relevant if permitted	User types its slash name
Editable by user	No	Yes	Yes
Supporting files	Not applicable	Yes: references, templates, examples, scripts	No dedicated skill directory
Automatic discovery	Product-controlled	Yes, based on skill description and invocation controls	Primarily explicit invocation
Team sharing	Installed with Claude Code	Commit project skill or distribute through a plugin	Commit .claude/commands/
Best use	Session and product controls	Reusable knowledge, checklists, and multi-step workflows	Maintaining an existing simple prompt shortcut

Custom commands have been merged into skills

Existing files under .claude/commands/ continue to work. You do not need to migrate them immediately. A legacy deploy.md and a skill named deploy both create /deploy.

Create a new skill when you need one or more of these features:

• automatic selection based on the task;
• supporting files or scripts;
• frontmatter that controls who can invoke it or which tools it may use;
• execution in an isolated subagent context;
• long reference material loaded only on demand; or
• compatibility with the Agent Skills open standard.

Keep a legacy command when it is a short, stable shortcut that already works and does not need the richer structure.

A skill does not automatically add a new external tool

The original comparison often described a skill as a callable API function. That is incorrect for Claude Code skills. A skill is primarily instructions, knowledge, and workflow. It can tell Claude to use tools Claude Code already has, or invoke a bundled script through an allowed execution tool, but the skill itself does not create network access or credentials.

If Claude needs to query a private database, update Jira, send a Slack message, or call an internal service, provide an appropriate tool—often through an MCP server or plugin—and configure permissions. The skill can then explain when and how to use that tool.

When MCP is the right solution

Use MCP when the missing piece is a callable external capability or structured resource:

• read deployment status from a service;
• query a database through a controlled interface;
• create or update an issue;
• retrieve a private API schema; or
• perform an action with typed parameters and structured output.

An MCP server may expose tools, resources, and prompts. A skill can orchestrate those capabilities into a repeatable procedure, but keep credentials and authorization in the tool configuration—not in SKILL.md.

When hooks are the right solution

Use a hook when an action must run at a defined lifecycle event rather than when Claude decides it is relevant. Examples include formatting a file after an edit, blocking a dangerous command before execution, injecting context at session start, or sending a notification when Claude needs input.

Skills are model-guided workflows; command hooks are deterministic automation. If a policy must always be enforced, a hook or external CI check is stronger than an instruction that the model could misunderstand.

When CLAUDE.md is the right solution

Put short, always-relevant project facts in CLAUDE.md: the package manager, test command, directory conventions, or an architectural rule. Move a long procedure into a skill so it loads only when needed.

A practical test is:

• “Claude should know this in every conversation” ? CLAUDE.md.
• “Claude should follow this playbook for a particular task” ? skill.
• “This must happen when an event occurs” ? hook.
• “Claude needs access to an external system” ? MCP tool or plugin.

How to design a useful skill

1. Write a precise description. State the trigger and outcome, not vague claims such as “helps with code.”
2. Keep the main procedure focused. Put detailed reference material in supporting files.
3. Define verification. Tell Claude what to run or inspect before claiming success.
4. Control side effects. Require confirmation for deployment, deletion, sending, or irreversible actions.
5. Test triggering. Check tasks where the skill should load, should not load, and should require explicit invocation.
6. Version it with the project. Review changes like code because a skill can influence commands and edits.

Bottom line

Do not choose between “skills” and “slash commands” as though one adds instructions and the other adds tools. In current Claude Code, a slash name is the invocation surface, and custom command files are the legacy form of skills. Use SKILL.md for new reusable workflows, built-in commands for Claude Code controls, MCP for external capabilities, and hooks for lifecycle automation.

Anthropic changes Claude Code frequently. Verify paths, frontmatter, substitutions, and bundled commands against the official Claude Code skills documentation for the version you run.