> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devin.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Skills

> Los skills ayudan a Cascade a gestionar tareas complejas de varios pasos.

Las tareas de ingeniería más complejas suelen requerir algo más que buenos prompts. Pueden requerir scripts de referencia, plantillas, listas de verificación y otros archivos de apoyo. Los skills te permiten agrupar todo esto en carpetas que Cascade puede invocar (leer y usar).

Los skills son una excelente forma de enseñarle a Cascade a ejecutar flujos de trabajo de varios pasos de manera consistente.

Cascade usa [**divulgación progresiva**](https://agentskills.io/what-are-skills#how-skills-work): de forma predeterminada, solo se muestran al modelo el `name` y la `description` del skill. El contenido completo de `SKILL.md` y los archivos de apoyo se cargan **solo cuando Cascade decide invocar el skill** (o cuando lo `@mention`). Esto mantiene tu ventana de contexto ligera incluso con muchos skills definidos.

Para obtener más detalles sobre la especificación de skills, visita [agentskills.io](https://agentskills.io/home).

<div id="how-to-create-a-skill">
  ## Cómo crear una Skill
</div>

<div id="using-the-ui-easiest">
  ### Cómo usar la UI (la forma más fácil)
</div>

1. Abre el panel de Cascade
2. Haz clic en los tres puntos de la esquina superior derecha del panel para abrir el menú de personalización
3. Haz clic en la sección `Skills`
4. Haz clic en `+ Workspace` para crear una skill de workspace (específica del proyecto) o en `+ Global` para crear una skill global
5. Ponle un nombre a la skill (solo letras minúsculas, números y guiones)

<div id="manual-creation">
  ### Creación manual
</div>

**Skill del workspace (específica del proyecto):**

1. Crea un directorio: `.windsurf/skills/<skill-name>/`
2. Agrega un archivo `SKILL.md` con frontmatter YAML

**Skill global (disponible en todos los workspaces):**

1. Crea un directorio: `~/.codeium/windsurf/skills/<skill-name>/`
2. Agrega un archivo `SKILL.md` con frontmatter YAML

<div id="skillmd-file-format">
  ## Formato del archivo SKILL.md
</div>

Cada skill requiere un archivo `SKILL.md` con frontmatter en YAML que contiene los metadatos de la skill:

<div id="example-skill">
  ### Skill de ejemplo
</div>

```markdown theme={null}
---
name: deploy-to-production
description: Guides the deployment process to production with safety checks
---

## Pre-deployment Checklist
1. Run all tests
2. Check for uncommitted changes
3. Verify environment variables

## Deployment Steps
Follow these steps to deploy safely...

[Reference supporting files in this directory as needed]
```

<div id="required-frontmatter-fields">
  ### Campos requeridos del frontmatter
</div>

* **name**: Identificador único de la skill (se muestra en la UI y se usa para las menciones con @)
* **description**: Breve explicación que se muestra al modelo para ayudarle a decidir cuándo invocar la skill

Ejemplos de nombres válidos: `deploy-to-staging`, `code-review`, `setup-dev-environment`

<div id="adding-supporting-resources">
  ## Agregar recursos de apoyo
</div>

Coloca cualquier archivo de apoyo en la carpeta de la skill, junto a `SKILL.md`. Estos archivos quedan disponibles para Cascade cuando se invoca la skill:

```
.windsurf/skills/deploy-to-production/
├── SKILL.md
├── deployment-checklist.md
├── rollback-procedure.md
└── config-template.yaml
```

<div id="invoking-skills">
  ## Invocar skills
</div>

<div id="automatic-invocation">
  ### Invocación automática
</div>

Cuando tu solicitud coincide con la descripción de un skill, Cascade invoca automáticamente ese skill y utiliza sus instrucciones y recursos para completar la tarea. Esta es la forma más habitual de usar los skills: simplemente describes lo que quieres hacer, y Cascade determina qué skills son relevantes.

El campo `description` del frontmatter de tu skill es clave: ayuda a Cascade a comprender cuándo debe invocar el skill. Escribe descripciones que expliquen claramente qué hace el skill y cuándo debe usarse.

<div id="manual-invocation">
  ### Invocación manual
</div>

Siempre puedes activar explícitamente una skill escribiendo `@skill-name` en el campo de entrada de Cascade. Esto resulta útil cuando quieres asegurarte de que se use una skill específica o cuando quieres invocar una skill que quizá no se active automáticamente con tu petición.

<div id="skill-scopes">
  ## Ámbitos de las skills
</div>

| Scope                | Ubicación                                    | Disponibilidad                                                        |
| -------------------- | -------------------------------------------- | --------------------------------------------------------------------- |
| workspace            | `.windsurf/skills/`                          | Solo en el espacio de trabajo actual. Se versiona con tu repositorio. |
| Global               | `~/.codeium/windsurf/skills/`                | Todos los espacios de trabajo de tu máquina. No se versiona.          |
| Sistema (Enterprise) | Específico del sistema operativo (ver abajo) | Todos los espacios de trabajo; lo distribuye TI. Solo lectura.        |

<Note>
  Para la compatibilidad entre agentes, Devin Desktop también detecta skills en `.agents/skills/` y `~/.agents/skills/`. Si has habilitado la lectura de la configuración de Claude Code, también se escanean `.claude/skills/` y `~/.claude/skills/`.
</Note>

<div id="system-level-skills-enterprise">
  ### skills del sistema (Enterprise)
</div>

Las organizaciones Enterprise pueden desplegar skills que están disponibles en todos los espacios de trabajo y que los usuarios finales no pueden modificar:

| SO        | Ruta                                            |
| --------- | ----------------------------------------------- |
| macOS     | `/Library/Application Support/Windsurf/skills/` |
| Linux/WSL | `/etc/windsurf/skills/`                         |
| Windows   | `C:\ProgramData\Windsurf\skills\`               |

Cada skill es un subdirectorio que contiene un archivo `SKILL.md`, igual que las skills del workspace.

<div id="example-use-cases">
  ## Ejemplos de casos de uso
</div>

<div id="deployment-workflow">
  ### Flujo de trabajo de despliegue
</div>

Crea una skill con scripts de despliegue, configuraciones de Environment y procedimientos de rollback:

```
.windsurf/skills/deploy-staging/
├── SKILL.md
├── pre-deploy-checks.sh
├── environment-template.env
└── rollback-steps.md
```

<div id="code-review-guidelines">
  ### Pautas para la revisión de código
</div>

Incluye guías de estilo, listas de verificación de seguridad y plantillas de revisión:

```
.windsurf/skills/code-review/
├── SKILL.md
├── style-guide.md
├── security-checklist.md
└── review-template.md
```

<div id="testing-procedures">
  ### Procedimientos de prueba
</div>

Agrupa plantillas de prueba, requisitos de cobertura y configuraciones de CI/CD:

```
.windsurf/skills/run-tests/
├── SKILL.md
├── test-template.py
├── coverage-config.json
└── ci-workflow.yaml
```

<div id="best-practices">
  ## Mejores prácticas
</div>

1. **Escribe descripciones claras**: La descripción ayuda a Cascade a decidir cuándo invocar la skill. Sé específico sobre lo que hace la skill y cuándo debe usarse.

2. **Incluye recursos relevantes**: Las plantillas, listas de verificación y ejemplos hacen que las skills sean más útiles. Piensa en qué archivos ayudarían a alguien a completar la tarea.

3. **Usa nombres descriptivos**: `deploy-to-staging` es mejor que `deploy1`. Los nombres deben indicar claramente lo que hace la skill.

<div id="skills-vs-rules-vs-workflows">
  ## skills vs Rules vs Workflows
</div>

Los tres personalizan Cascade, pero difieren en **estructura**, **invocación** y **coste de contexto**:

|                                | skills                                                                                      | Rules                                                      | Workflows                                                 |
| ------------------------------ | ------------------------------------------------------------------------------------------- | ---------------------------------------------------------- | --------------------------------------------------------- |
| **Propósito**                  | Procedimientos de varios pasos con archivos auxiliares                                      | Pautas de comportamiento ("cómo comportarse")              | Plantillas de prompt para tareas repetibles               |
| **Estructura**                 | Carpeta con `SKILL.md` + cualquier archivo de recursos                                      | Un único archivo `.md` con frontmatter                     | Un único archivo `.md`                                    |
| **Invocación**                 | El modelo decide (divulgación progresiva) o `@mention`                                      | `always_on` / `glob` / `model_decision` / `manual`         | **Solo manual** mediante `/slash-command`                 |
| **¿En el prompt del sistema?** | No — solo el nombre + la descripción hasta que se invoca                                    | Depende del modo de activación                             | No — aparecen listados como comandos disponibles          |
| **Ideal para**                 | Despliegues, revisión de código, procedimientos de testing que requieren scripts/plantillas | Estilo de código, convenciones del proyecto, restricciones | Runbooks de una sola ejecución que activas explícitamente |

**Regla general:** si Cascade debe detectarlo automáticamente *y* necesita archivos auxiliares, usa un skill. Si es una restricción breve de comportamiento, usa un Rule. Si siempre quieres activarlo tú mismo, usa un Workflow.

<div id="related-documentation">
  ## Documentación relacionada
</div>

Si skills no es lo que buscas, consulta estas otras funciones de Cascade:

* **[Workflows](./workflows)** - Automatiza tareas repetitivas con workflows reutilizables en Markdown invocados mediante comandos de barra diagonal
* **[AGENTS.md](./agents-md)** - Proporciona instrucciones de ámbito de directorio que se aplican automáticamente según la ubicación del archivo
* **[Memories & Rules](./memories)** - Conserva el contexto entre conversaciones con memorias generadas automáticamente y Rules definidas por el usuario