> ## Documentation Index
> Fetch the complete documentation index at: https://cisco-ea52c096.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Skills

> Reusable prompt workflows you can invoke with a slash command. Create custom skills for your team or project, or use the built-in ones that ship with Claude Code.

## What are skills?

A skill is a named, reusable prompt workflow stored as a Markdown file. When you type `/skill-name` in a session, Claude Code loads the skill's instructions and executes them. Skills are useful for:

* Repeatable tasks you run often (e.g. `/review`, `/document`, `/refactor`)
* Team conventions you want to encode once and reuse everywhere
* Complex workflows that would be tedious to type out each time

## Built-in skills

Claude Code ships with a set of built-in skills that are available in every session:

| Skill | Description |
| - | - |
| `/verify` | Verify that the work done matches the original request |
| `/debug` | Systematic debugging workflow |
| `/simplify` | Simplify complex code or text |
| `/remember` | Store information in persistent memory |
| `/skillify` | Convert a workflow into a reusable skill |
| `/batch` | Run a workflow across multiple items |
| `/stuck` | Get unstuck when progress stalls |
| `/update-config` | Update Claude Code configuration |
| `/keybindings` | Set up terminal key bindings |

Built-in plugins can provide additional skills. See the [Plugins](/configuration/plugins) page for details.

## The /skills command

Run `/skills` in a session to open the skills browser. From there you can:

* See all available skills (built-in, user, and project)
* View a skill's description and usage hints
* Invoke a skill directly from the list

## Skill directories

Claude Code loads skills from the following locations, in priority order:

| Scope | Path |
| - | - |
| Managed (policy) | `<managed-path>/.claude/skills/` |
| User | `~/.claude/skills/` |
| Project | `.claude/skills/` (walked up to home) |

Skills closer to the project root take precedence over user-level skills with the same name.

<Note>
  Claude Code also supports a legacy `~/.claude/commands/` directory for backward compatibility. New skills should use the `skills/` directory format.
</Note>

## Creating a custom skill

Each skill lives in its own subdirectory under a `skills/` folder. The directory name becomes the slash command name.

<Steps>
  <Step title="Create the skill directory">
    ```bash theme={null}
    mkdir -p .claude/skills/my-skill
    ```
  </Step>

  <Step title="Create the SKILL.md file">
    Create `.claude/skills/my-skill/SKILL.md` with your skill's instructions:

    ```markdown theme={null}
    ---
    description: Review the code for security issues and suggest fixes
    argument-hint: "[file or description]"
    allowed-tools: Read, Grep, Glob
    ---

    Review the following code for security vulnerabilities.

    Focus on:
    - SQL injection
    - XSS vulnerabilities
    - Insecure dependencies
    - Hardcoded secrets

    For each issue found, explain the risk and suggest a concrete fix.

    $ARGUMENTS
    ```
  </Step>

  <Step title="Invoke the skill">
    In a Claude Code session, type:

    ```
    /my-skill src/api/auth.ts
    ```
  </Step>
</Steps>

## Frontmatter reference

Skills support YAML frontmatter at the top of `SKILL.md` to control their behavior:

<ParamField path="description" type="string">
  Short description shown in `/skills` and autocomplete.
</ParamField>

<ParamField path="argument-hint" type="string">
  Hint shown next to the skill name when typing (e.g. `"[file]"`).
</ParamField>

<ParamField path="allowed-tools" type="string">
  Comma-separated list of tools this skill is allowed to use (e.g. `"Read, Write, Bash"`).
</ParamField>

<ParamField path="model" type="string">
  Override the model used for this skill (e.g. `"claude-sonnet-4-6"`). Use `"inherit"` to use the session default.
</ParamField>

<ParamField path="when_to_use" type="string">
  Guidance for Claude on when to automatically invoke this skill.
</ParamField>

<ParamField path="user-invocable" type="boolean">
  Set to `false` to hide the skill from user-facing autocomplete. It can still be invoked by the model internally.
</ParamField>

<ParamField path="context" type="string">
  Set to `"fork"` to run the skill in an isolated context fork.
</ParamField>

<ParamField path="effort" type="string">
  Control the reasoning effort level. Accepts a named level or an integer.
</ParamField>

<ParamField path="paths" type="string">
  Gitignore-style path patterns. The skill is only activated when Claude operates on matching files (e.g. `"src/**/*.ts"`). Skills with `paths` are loaded lazily and activated on first file match.
</ParamField>

<ParamField path="hooks" type="object">
  Hooks scoped to this skill. Use the same format as global hooks in `settings.json`.
</ParamField>

## Example skill definitions

### Code reviewer with path scoping

```markdown theme={null}
---
description: Review TypeScript files for best practices
paths: "**/*.ts"
allowed-tools: Read, Grep
---

Review this TypeScript file for:
- Type safety issues
- Missing error handling
- Performance anti-patterns

$ARGUMENTS
```

### Multi-step workflow

```markdown theme={null}
---
description: Create a GitHub PR with tests and docs
allowed-tools: Bash, Read, Write, Glob
argument-hint: "[branch description]"
---

Create a pull request for the current branch:

1. Run the test suite and confirm all tests pass
2. Check for missing documentation on any new public APIs
3. Write a clear PR description summarizing the changes
4. Create the PR with `gh pr create`

Branch context: $ARGUMENTS
```

## Dynamic skill discovery

Claude Code automatically discovers skills inside subdirectories as you work. When you read or write a file, Claude Code walks up the directory tree looking for `.claude/skills/` directories. Newly discovered skills become available immediately without restarting the session.

<Tip>
  Skills with a `paths` frontmatter are stored as conditional skills and only activated when Claude operates on a file matching the pattern. This keeps the skill list focused and avoids context bloat.
</Tip>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.