> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/cline/cline/llms.txt
> Use this file to discover all available pages before exploring further.
# Skills
> Modular instruction sets that extend Cline's capabilities for specific tasks, loaded on-demand to keep context lean.
Skills are modular instruction sets that extend Cline's capabilities for specific tasks. Each skill packages detailed guidance, workflows, and optional resources that Cline loads only when relevant to your request.
Install multiple skills and Cline only loads what it needs. A deployment skill stays dormant until you ask about deploying. Unlike [rules](/customization/cline-rules) (which are always active), skills load on-demand so they don't consume context when you're working on something unrelated.
Skills is an experimental feature. Enable it in **Settings → Features → Enable Skills**.
## How skills work
Skills use progressive loading to maximize efficiency:
| Level | When loaded | Token cost | Content |
| ------------ | ----------------------- | ---------------------- | ---------------------------------------------------------- |
| Metadata | Always (at startup) | \~100 tokens per skill | `name` and `description` from YAML frontmatter |
| Instructions | When skill is triggered | Under 5k tokens | `SKILL.md` body with instructions and guidance |
| Resources | As needed | Effectively unlimited | Bundled files accessed via `read_file` or executed scripts |
When you send a message, Cline sees a list of available skills with their descriptions. If your request matches a skill's description, Cline activates it using the `use_skill` tool, which loads the full instructions from `SKILL.md`.
## Skill structure
Every skill is a directory containing a `SKILL.md` file with YAML frontmatter:
```text theme={null}
my-skill/
├── SKILL.md # Required: main instructions
├── docs/ # Optional: additional documentation
│ └── advanced.md
└── scripts/ # Optional: utility scripts
└── validate.sh
```
The `SKILL.md` file has two parts: metadata and instructions.
```markdown theme={null}
---
name: my-skill
description: Brief description of what this skill does and when to use it.
---
# My skill
Detailed instructions for Cline to follow when this skill is activated.
## Steps
1. First, do this
2. Then do that
3. For advanced usage, see [advanced.md](docs/advanced.md)
```
Required fields:
* `name` must exactly match the directory name
* `description` tells Cline when to use this skill (max 1024 characters)
## Creating a skill
Click the scale icon at the bottom of the Cline panel, to the left of the model selector. Switch to the **Skills** tab.
Click **New skill...** and enter a name (e.g., `aws-deploy`). Cline creates a skill directory with a template `SKILL.md` file.
Edit the `SKILL.md` file:
* Update the `description` field to specify when this skill should trigger
* Add detailed instructions in the body
* Optionally add supporting files in `docs/`, `templates/`, or `scripts/` subdirectories
You can also create skills manually by creating the directory structure in your file system. Place skill directories in `.cline/skills/` (workspace) or `~/.cline/skills/` (global) and Cline will detect them automatically.
### Toggling skills
Every skill has a toggle to enable or disable it without deleting the skill directory. Skills are enabled by default when discovered.
For example, you might disable a CI/CD skill when working on local development, or enable a client-specific skill only when working on that client's project.
## Where skills live
Skills can be stored globally or in a project workspace:
| Location | Path |
| --------------------- | ---------------------------------- |
| Project (recommended) | `.cline/skills/` |
| Project (alternate) | `.clinerules/skills/` |
| Global (macOS/Linux) | `~/.cline/skills/` |
| Global (Windows) | `C:\Users\USERNAME\.cline\skills\` |
When a global skill and project skill have the same name, the global skill takes precedence. Version control your project skills by committing `.cline/skills/` so your team can share, review, and improve them together.
## Writing effective SKILL.md files
### Naming conventions
The skill name appears in the `name` field and must match the directory name exactly. Use lowercase with hyphens (kebab-case).
```text Good names theme={null}
aws-cdk-deploy
pr-review-checklist
database-migration
api-client-generator
```
```text Avoid theme={null}
aws # Too vague
my_skill # Underscores instead of hyphens
DeployToAWS # Not kebab-case
misc-helpers # Too generic
```
### Writing effective descriptions
The description determines when Cline activates the skill. A vague description means the skill won't trigger when you expect it to.
```yaml Good descriptions theme={null}
description: Deploy applications to AWS using CDK. Use when deploying,
updating infrastructure, or managing AWS resources.
description: Generate release notes from git commits. Use when preparing
releases, writing changelogs, or summarizing recent changes.
description: Analyze CSV and Excel data files. Use when exploring datasets,
generating statistics, or creating visualizations from tabular data.
```
```yaml Weak descriptions theme={null}
description: Helps with AWS stuff.
description: Data analysis helper.
description: Useful for releases.
```
Start with what the skill does (action verbs), include trigger phrases users might say, and mention specific file types, tools, or domains.
### Keeping skills focused
Keep `SKILL.md` under 5k tokens. If your skill needs more content, split it into separate files in a `docs/` directory and reference them from the main instructions. Cline loads referenced files only when needed.
Put the important information first. Cline reads the file sequentially, so front-load the common cases. Include real examples — show what commands to run, what output to expect, and what the result should look like.
## Bundling supporting files
Skills can include additional files that Cline accesses only when needed:
```text theme={null}
complex-skill/
├── SKILL.md
├── docs/
│ ├── setup.md
│ └── troubleshooting.md
├── templates/
│ └── config.yaml
└── scripts/
└── validate.py
```
Use `docs/` for information that's too detailed for `SKILL.md` or only relevant in specific situations:
* Advanced configuration options
* Troubleshooting guides for edge cases
* Reference material (API schemas, database schemas)
* Platform-specific instructions
A deployment skill might have `docs/aws.md`, `docs/gcp.md`, and `docs/azure.md`. Cline loads only the relevant platform guide based on your request.
Use `templates/` when your skill creates configuration files, boilerplate code, or structured documents:
* Config files (Terraform, Docker Compose, CI/CD pipelines)
* Code scaffolding (component templates, test fixtures)
* Documentation templates (README, API docs)
A project setup skill could include `templates/dockerfile`, `templates/docker-compose.yml`, and `templates/.env.example` that Cline customizes for each new project.
Use `scripts/` for operations where you want consistent, predictable behavior:
* Validation (linting configs, checking prerequisites)
* Data processing (parsing, formatting, transforming)
* Complex calculations (cost estimation, resource sizing)
* API interactions (fetching data, running health checks)
Scripts are token-efficient because only their output enters context, not the script code itself. A 500-line validation script produces a simple "Passed" or detailed error messages without consuming any context for the script logic.
### Referencing bundled files
Reference supporting files directly in your `SKILL.md` instructions:
````markdown theme={null}
For initial setup, follow [setup.md](docs/setup.md).
Use the config template at `templates/config.yaml` as a starting point.
Run the validation script to check your configuration:
```python
python scripts/validate.py
````
````
Cline reads documentation files using `read_file` when the instructions reference them. Scripts can be executed directly, and only the script's output enters the context window.
## Example skill
Here's a complete skill for data analysis tasks. Create a directory called `data-analysis/` in `.cline/skills/` with this `SKILL.md`:
```markdown
---
name: data-analysis
description: Analyze data files and generate insights. Use when working with
CSV, Excel, or JSON data files that need exploration, cleaning, or
visualization.
---
# Data analysis
When analyzing data files, follow this workflow:
## 1. Understand the data
- Read a sample of the file to understand its structure
- Identify column types and data quality issues
- Note any missing values or anomalies
## 2. Ask clarifying questions
Before diving in, ask the user:
- What specific insights are they looking for?
- Are there any known data quality issues?
- What format do they want for the output?
## 3. Perform analysis
Use pandas for data manipulation:
```python
import pandas as pd
# Load and explore
df = pd.read_csv("data.csv")
print(df.head())
print(df.describe())
print(df.info())
````
For visualization, prefer matplotlib for simple charts and seaborn for
statistical plots.
## 4. Present results
* Lead with the most important finding
* Include relevant charts or tables
* Flag data quality issues that may affect conclusions
```
Skills transform Cline from a general-purpose assistant into a specialist that knows your domain. Start with one skill for a task you repeat often, test it, and iterate on the description until it triggers reliably.
```