---
title: "Skills: installing specific capabilities in your AI agent"
description: "What a Skill is, what a SKILL.md file contains and three ways to install one in Claude Code, Cursor or Windsurf: from skills.sh, a local file or the agent itself. Devlights Tech Tips, episode 4."
url: "https://www.devlights.com/blog/ai-agent-skills-installation"
language: en
published: 2026-10-22T13:00:00.000Z
updated: 2026-10-28T22:29:55.771Z
type: article
authors: ["Pablo Merino"]
category: "Tech Tips"
tags: ["Skills", "Coding agents", "Claude Code", "Cursor", "Windsurf", "AI", "Skills.sh", "Software development", "Tech Tips"]
---

# Skills: installing specific capabilities in your AI agent

> What a Skill is, what a SKILL.md file contains and the three ways to install Skills in Claude Code, Cursor or Windsurf: from skills.sh, from a local file or by asking the agent itself.

> **TL;DR**
>
> **This article is part of the Devlights Tech Tips series on AI applied to technical work.** If you missed the previous episodes: model, agent and tools · tokens and context window · AGENTS.md.

📺 [**Watch the video on Instagram**](https://www.instagram.com/reel/DZyDrKaJ70j/)

AI agents are powerful out of the box. But with **Skills**, you install specific capabilities for your project's concrete tasks. In this episode we show you how they work and the three ways to install them.

## What is a Skill?

A Skill is a Markdown file with structured instructions that tell the agent how to do something specific: which best practices to follow, which patterns to use, which mistakes to avoid.

Instead of repeating those instructions every time you start a task, the Skill encapsulates them and makes them **reusable**. You can use them in Claude Code, Cursor, Windsurf or Copilot; the concept is the same in all of them.

```
Without a Skill → you repeat the same instructions every time
With a Skill    → the knowledge is encapsulated and reusable
```

## What's inside a Skill

A well-written Skill has a clear, predictable structure. Four sections define the file:

```
markdown

# Name and description
What this Skill does and when the agent should use it.

# Detailed instructions and rules
The step-by-step for approaching the task correctly.

# Examples and use cases
Concrete situations where the Skill applies, with real examples.

# Rules: what to avoid
Common mistakes or patterns the agent must not follow.
```

Anyone can open the file and understand exactly what it does, without having to run it. It's documentation and behavior at the same time.

### An important detail: Skills aren't all loaded at once

The agent detects the context you're working in and loads only the Skill it needs at that moment. If you're working on frontend, it loads the frontend Skill. If you're writing tests, it loads the testing one.

This avoids flooding the context with instructions that are irrelevant to the current task, something that, as we saw in the context window episode, has a real cost in response quality.

## The three ways to install a Skill

### 1. From a public catalog: skills.sh

The fastest option when you're looking for a capability that already exists. **skills.sh** works as a central catalog of Skills, the npm of agents.

The flow is simple:

1. Search the catalog for what you need.
2. Check the author and repository before installing (just as you would with any npm package).
3. Copy the `npx` command the page gives you.
4. Run it in your project and select the agent you'll use it with.

Real example: installing `find-skills`, by **vercel-labs**.

```
bash

npx find-skills@latest install
# Select: Claude Code
```

Once it runs, the Skill is immediately available in your project.

### 2. From a local file

If you have a Skill you created yourself or downloaded from a repository, the second option is straightforward: copy it into the right folder in your project.

```
.claude/skills/    → for Claude Code
.cursor/skills/    → for Cursor
```

The agent picks it up automatically the next time it starts, with no extra steps.

This option is especially useful for **your team's own Skills** that aren't published in any catalog: internal knowledge, client-specific conventions or project-specific workflows.

### 3. Asking the agent to install it

The third option is the most direct of all: ask the agent itself.

Once you have `find-skills` installed (using the first option), you can just tell it:

```
"Find a Skill for working with Pull Requests"
```

The agent looks for real options within the ecosystem, shows you which ones exist, and from there you can ask it to install the one you picked. You go from a concrete need, "I want to work better with PRs", to a ready-to-use Skill, all from the same chat, without searching manually.

## Why this matters beyond convenience

Skills are how **technical knowledge becomes reusable**. It doesn't stay trapped in one team member's head; it lives in the repository, versioned and documented, and any agent can use it.

It's the difference between relying on someone remembering to tell the agent "this is how we do tests here" every single time, and having that instruction already encapsulated and ready for any developer on the team to use.

The ecosystem grows every week: there are already Skills for testing, migrations, design, documentation and much more. And, as we saw, you can also create your own for your team or your project.

**Coming up in the next episode**

So far we've seen how to give the agent persistent context (AGENTS.md) and how to install specific capabilities (Skills). The next logical step points outward: how to make any model efficiently understand your website's content.

In the next video we cover **llms.txt**.