---
lastModified: 2026-09-27
---

# Skills

Skills are directories that contain instructions and optional resources for specific tasks. Amp
includes built-in skills. You can also keep skills in a project, install them on one machine, or
publish them for yourself or your workspace.

## Creating and Installing Skills

Amp has a built-in `building-skills` skill that can create or install skills for you. Ask Amp:

```prompt
Create a project skill for deploying this app to staging
```

```prompt
Create a personal skill for my release notes workflow
```

```prompt
Install the skills from github.com/example/engineering-skills
```

Project skills are saved under `.agents/skills/` and can be committed with the project. Personal
skills are available everywhere you use Amp. For direct shell installation from a GitHub
repository, Git URL, or local path, run `amp skill add <source>`. Pass `--global` to install it only
on the current machine under `~/.config/agents/skills/`.

## Skill Sources and Precedence

Amp uses the first skill with a given frontmatter `name`. The order is:

1. `~/.config/agents/skills/`
2. `~/.agents/skills/`
3. `~/.config/amp/skills/`
4. `.agents/skills/` in the project and searched parent directories
5. `.claude/skills/` in those directories
6. `~/.claude/skills/`
7. `~/.claude/plugins/cache/`
8. Directories in `amp.skills.path`, in the order they are configured
9. Your personal skills repository
10. Your active workspace skills repository
11. Official Amp skills

Local skills mask repository skills with the same name. A personal skill masks a workspace skill
with the same name, and both mask official Amp skills. Set `amp.skills.disableClaudeCodeSkills` in
[Configuration](/docs/cli/settings) to skip the Claude-compatible locations, or
`amp.skills.disableGlobalAgentsSkills` to skip `~/.config/agents/skills/` and `~/.agents/skills/`.

Amp searches local skill directories recursively, up to five directories below each skills root.
For example, it discovers `~/.agents/skills/something/deep/SKILL.md`; the directory containing
`SKILL.md` is the skill directory. Personal and workspace skills repositories have a different
layout: each skill must be in an immediate child directory of the repository root.

An active directory plugin can also register a bundled skill. Amp gives it the qualified name
`<plugin-name>:<skill-name>`, so it does not compete with the bare skill names above.

## Viewing and Reloading Skills

You can ask Amp:

```prompt
List the skills available in this thread and where each one came from
```

```prompt
Reload my skills
```

For direct inspection, run `amp skills list`, add `--json` for machine-readable output, or open the
interactive CLI command palette with <kbd>Ctrl+O</kbd> and run `skills: list`. The `reload_skills`
tool rescans local directories and fetches the latest personal and workspace skills. Running
`amp skills list` in another shell does not reload an existing session.

## Skill Repositories

Personal skills are available everywhere you use Amp. Workspace admins manage workspace skills,
which are available to everyone in the workspace. Amp stores each scope in its own Git repository.

The simplest way to manage these skills is to ask Amp in a thread. For example:

```prompt
Create a personal skill for writing my release notes
```

```prompt
Create a workspace skill for deploying our staging environment
```

```prompt
Import this shared skill into my workspace skills: <shared-skill-url>
```

```prompt
Update the imported release-notes skill in my workspace skills
```

Amp finds the right repository and prepares the change in a checkout. It reviews and commits the
change, then asks before pushing. A push publishes the skill. New threads load it automatically,
and Amp can reload it in the current thread.

To share a personal skill, open **Skills** in [Personal Settings](/settings/skills). Select the
skill, choose **Share**, make it available to the workspace, and copy its URL. Send the URL directly
or paste it into Slack, where it unfurls with details about the skill. Teammates can paste the URL
into a thread or ask Amp, "Has anyone got a release-notes skill?"

If you edit a repository directly, put each skill in a top-level directory with `SKILL.md` directly
inside it. The directory name and the `name` in `SKILL.md` must match.

```text
release-notes/
├── SKILL.md
├── scripts/
└── references/
```

For direct shell access, `amp skills repositories` lists the repositories and clone commands.
`amp clone user-skills` and `amp clone workspace-skills` clone them. The `amp skill import` and
`amp skill update` commands manage shared imports. Repository owners can require signed commits in
the repository's Advanced settings.

### Hosted repository limits

Each personal or workspace skills repository has a limit of 200 skills. The limit applies to each
repository separately, not to the combined list of skills in a thread.

If a Git push puts more than 200 skills in a repository, Amp selects only the first 200 skill
directories in alphabetical order. The remaining skills are not available, even after a reload or
in a new thread. A successful push does not mean that every skill can be loaded. Skill imports and
writes through the API reject additions that would exceed the limit.

The following limits also apply. Amp checks these after selecting the first 200 skill directories,
so fewer than 200 skills can be available.

| Resource                              | Limit  |
| ------------------------------------- | ------ |
| Files per skill, including `SKILL.md` | 200    |
| Size of one file                      | 10 MiB |
| Total size of one skill               | 25 MiB |
| Total repository size                 | 25 MiB |

Hosted skill files must be text files. These hosted repository limits do not apply to project or
machine-local skill directories.

## Skill Format

Each skill is a directory containing a `SKILL.md` file with YAML frontmatter:

```markdown
---
name: my-skill
description: A description of what this skill does
---

# My Skill Instructions

Detailed instructions for the agent...
```

Amp lists every discovered skill for the model. The model sees each skill's `name` and `description`
and uses them to decide when to load it. Amp loads the rest of `SKILL.md` only when the skill is
invoked.

Skills can include scripts, templates, and reference files in the same directory. The agent can
access these files by paths relative to the skill directory.

## MCP Servers in Skills

A skill can define MCP servers in a sibling `mcp.json` file or in the `mcpServers` field of its
`SKILL.md` frontmatter. If both are present, Amp uses `mcpServers` and ignores `mcp.json`.

Amp connects to skill MCP servers when it discovers the skill. Amp hides tools from a server
defined only by a skill until the skill is loaded. If a server with the same name is also supplied
by a CLI flag or direct configuration, that source takes precedence and its tools remain visible.

**Example `mcp.json` for a local command-based server:**

```json
{
	"chrome-devtools": {
		"command": "npx",
		"args": ["-y", "chrome-devtools-mcp@latest"],
		"includeTools": ["navigate_*", "take_screenshot", "click", "fill*"]
	}
}
```

**Example `mcp.json` for a remote HTTP server:**

```json
{
	"linear": {
		"url": "https://mcp.linear.app/sse",
		"includeTools": ["list_issues", "create_issue", "update_issue"]
	}
}
```

**Fields for local servers:**

- `command` (`string`) is the command to run.
- `args` (`string[]`, optional) contains the command arguments.
- `env` (`object`, optional) contains the environment variables.

**Fields for remote servers:**

- `url` (`string`) is the server endpoint.
- `headers` (`object`, optional) contains the HTTP headers to send with requests.

**Common fields:**

- `includeTools` (`string[]`, optional but recommended) contains tool names or glob patterns used
  to choose which tools are exposed.
