> ## 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.

# Cómo crear skills

> Referencia completa del formato SKILL.md y las opciones de frontmatter

Las skills se definen como archivos `SKILL.md` dentro de un directorio con un nombre específico. Esta página explica todo lo que necesitas saber para escribir skills eficaces.

***

<div id="file-structure">
  ## Estructura de archivos
</div>

Coloca las skills en el directorio correspondiente según el ámbito:

```
# Específico del proyecto (confirmado en git)
.devin/skills/
└── my-skill/
    └── SKILL.md

# Global — disponible en todos los proyectos (no confirmado)
# Linux/macOS:
~/.config/devin/skills/
└── my-skill/
    └── SKILL.md

# Windows:
%APPDATA%\devin\skills\
└── my-skill\
    └── SKILL.md
```

El nombre del directorio es el identificador de la skill (se usa para la invocación de `/my-skill`). El archivo `SKILL.md` contiene frontmatter YAML opcional y el contenido del prompt de la skill.

<Note>
  En Windows, `%APPDATA%` normalmente se resuelve a `C:\Users\<YourUser>\AppData\Roaming`.
</Note>

***

<div id="frontmatter-reference">
  ## Referencia de frontmatter
</div>

```yaml theme={null}
---
name: my-skill
description: What this skill does (shown in completions)
argument-hint: "[file] [options]"
model: sonnet
subagent: true
allowed-tools:
  - read
  - grep
  - glob
  - exec
permissions:
  allow:
    - Read(src/**)
  deny:
    - exec
  ask:
    - Write(**)
triggers:
  - user
  - model
---

Your prompt content goes here...
```

<div id="all-frontmatter-fields">
  ### Todos los campos del frontmatter
</div>

| Campo           | Tipo    | Predeterminado         | Descripción                                                                                                                  |
| --------------- | ------- | ---------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| `name`          | string  | nombre del directorio  | Nombre visible de la skill                                                                                                   |
| `description`   | string  | ninguno                | Se muestra en las sugerencias de autocompletado del comando de barra diagonal                                                |
| `argument-hint` | string  | ninguno                | Sugerencia que se muestra después del nombre del comando (p. ej., `[filename]`)                                              |
| `model`         | string  | modelo actual          | Anula el modelo usado al ejecutar esta skill                                                                                 |
| `subagent`      | boolean | `false`                | Ejecuta la skill como un [subagente](/es/cli/subagents) en lugar de inline                                                   |
| `agent`         | string  | ninguno                | Ejecuta la skill como un subagente con un perfil específico de [subagente personalizado](/es/cli/subagents#custom-subagents) |
| `allowed-tools` | list    | todas las herramientas | Restringe qué herramientas puede usar la skill                                                                               |
| `permissions`   | object  | heredar                | Anulaciones de permisos para esta skill                                                                                      |
| `triggers`      | list    | `[user, model]`        | Cómo se puede invocar la skill                                                                                               |

***

<div id="model-override">
  ## Anulación del modelo
</div>

Usa el campo `model` para ejecutar una skill con un modelo distinto del que está activo en la sesión actual. Esto es útil para usar un modelo más rápido en tareas simples o uno más potente en tareas complejas:

```yaml theme={null}
---
name: quick-fix
description: Fast lint fix using a lightweight model
model: swe
---

Fix the lint errors in the current file.
```

El nombre del modelo usa los mismos valores que la marca `--model` de la CLI (p. ej., `opus`, `sonnet`, `swe`, `codex`). Consulta [Models](/es/cli/models) para ver la lista completa. Cuando la skill termina, la sesión vuelve al modelo que estaba activo anteriormente.

***

<div id="running-skills-as-subagents">
  ## Ejecutar skills como subagentes
</div>

<Warning>
  Ejecutar skills como subagentes es **experimental**. Los campos de frontmatter `subagent` y `agent` pueden cambiar en futuras versiones.
</Warning>

De forma predeterminada, el prompt de una skill se inserta en la conversación actual; el agente lo procesa en línea. Como alternativa, puedes ejecutar una skill como **subagente**, lo que crea un proceso independiente con su propia ventana de contexto. Esto resulta útil para skills que realizan tareas específicas y autocontenidas, cuando no quieres que la salida llene la conversación principal.

Hay dos formas de ejecutar una skill como subagente:

<div id="subagent-true">
  ### `subagent: true`
</div>

Establece `subagent: true` para ejecutar la skill como un subagente con el perfil `subagent_general` predeterminado:

```yaml theme={null}
---
name: deep-research
description: Thorough codebase research on a topic
subagent: true
model: sonnet
allowed-tools:
  - read
  - grep
  - glob
---

Research the topic the user asked about thoroughly.

Search broadly, follow references, and trace call chains.
Report all findings with specific file paths and line numbers.
```

Cuando se invoca, esta skill crea un subagente en primer plano que ejecuta el prompt de la skill como tarea. El agente principal espera a que el subagente finalice; luego lee y resume los resultados.

<div id="agent-profile">
  ### `agent: <profile>`
</div>

Usa el campo `agent` para ejecutar la skill como un subagente con un [perfil personalizado de subagente](/es/cli/subagents#custom-subagents):

```yaml theme={null}
---
name: review-pr
description: Review the current PR using the reviewer subagent
agent: reviewer
---

Review the staged changes for correctness, security, and style issues.
```

El valor de `agent` debe coincidir con el nombre de un perfil de subagente registrado (ya sea uno integrado, como `subagent_explore` / `subagent_general`, o un perfil personalizado que hayas definido). El subagente hereda el prompt del sistema, las restricciones de herramientas y el modelo del perfil, mientras que el contenido de la skill pasa a ser la tarea.

<Note>
  Si se establecen tanto `agent` como `subagent`, `agent` tiene prioridad. El campo `model` de la skill anula el modelo del perfil del subagente cuando se especifican ambos.
</Note>

<Note>
  Las skills que se ejecutan como subagentes no crean subagentes anidados: si la skill ya se está ejecutando dentro de un subagente, se ejecuta inline para evitar la recursión infinita.
</Note>

<div id="orchestrating-subagents-using-skills">
  ### Orquestación de subagentes con skills
</div>

Como las skills pueden ejecutarse como subagentes, puedes usarlas para orquestar flujos de trabajo de varios pasos. Define un conjunto de skills de subagentes, cada una encargada de una tarea concreta, y luego escribe una skill normal que las invoque. La skill externa se convierte en el orquestador: llama a cada subagente, recopila los resultados y decide qué hacer a continuación.

Por ejemplo, aquí tienes dos skills de subagentes y un orquestador que las coordina:

```markdown theme={null}
---
name: research-changes
description: Research recent code changes and their impact
subagent: true
allowed-tools:
  - read
  - grep
  - glob
  - exec
---

Analyze the recent changes in this repository:

1. Run `git log --oneline -20` to see recent commits
2. For each significant commit, examine what changed and why
3. Identify any patterns, risks, or areas that need attention

Report your findings with specific file paths and commit references.
```

```markdown theme={null}
---
name: validate-tests
description: Run tests and validate coverage for recent changes
subagent: true
allowed-tools:
  - read
  - grep
  - glob
  - exec
---

Validate the test suite for the project:

1. Identify the test framework and run command
2. Run the full test suite
3. Check for any failing tests
4. Review test coverage for recently changed files

Report which tests pass, which fail, and any coverage gaps.
```

```markdown theme={null}
---
name: health-check
description: Full project health check — research changes then validate tests
---

Perform a full health check on this project:

1. First, use the /research-changes skill to understand recent changes
2. Then, use the /validate-tests skill to verify the test suite
3. Finally, synthesize the findings from both into a summary:
   - What changed recently and why
   - Whether tests are passing
   - Any risks or recommended actions
```

Al invocar `/health-check`, se ejecuta el orquestador en el agente principal. Este llama a `/research-changes`, que crea un subagente para explorar el repo. Cuando termina, llama a `/validate-tests`, que crea otro subagente para ejecutar las pruebas. Luego, el orquestador sintetiza ambos resultados en un resumen final.

Una skill de subagente **nunca** usará un subagente al llamar a otras skills, incluso si esas skills tienen `subagent: true`; en esos casos, se ejecutan inline. Esto significa que no tienes que preocuparte por un anidamiento ilimitado. El patrón de orquestación siempre tiene un solo nivel de profundidad: el orquestador crea subagentes, y esos subagentes ejecutan todo lo demás inline.

***

<div id="prompt-content">
  ## Contenido del prompt
</div>

El contenido del archivo SKILL.md (después del frontmatter) es el prompt que se inserta cuando se invoca la skill.

***

<div id="permissions">
  ## Permisos
</div>

Las skills pueden definir su propio ámbito de permisos con la misma sintaxis que la configuración principal de permisos:

```yaml theme={null}
permissions:
  allow:
    - Read(src/**)
    - Exec(npm run test)
  deny:
    - Write(/etc/**)
    - exec
  ask:
    - Write(src/**)
```

**Cómo funcionan los permisos de skill:**

* `allow` — Estos ámbitos se aprueban automáticamente durante la ejecución de la skill
* `deny` — Estos ámbitos se bloquean durante la ejecución de la skill
* `ask` — Estos ámbitos siempre requieren la aprobación del usuario

<Note>
  Los permisos de la skill son aditivos respecto a los permisos base de la sesión (no los reemplazan). Una skill no puede otorgar permisos que estén denegados en un nivel superior (configuración del proyecto o de la organización).
</Note>

***

<div id="allowed-tools">
  ## Herramientas permitidas
</div>

Restringe las herramientas que puede usar la skill:

```yaml theme={null}
allowed-tools:
  - read
  - grep
  - glob
```

Nombres de las herramientas disponibles: `read`, `edit`, `grep`, `glob`, `exec`

También puedes permitir herramientas MCP:

```yaml theme={null}
allowed-tools:
  - read
  - mcp__github__list_issues
  - mcp__github__create_issue
```

<Warning>
  Si no se especifica `allowed-tools`, la skill tiene acceso a todas las herramientas. En las skills críticas para la seguridad, limita siempre el acceso al mínimo necesario.
</Warning>

***

<div id="examples">
  ## Ejemplos
</div>

<div id="code-review-skill">
  ### Skill para revisar código
</div>

```markdown theme={null}
---
name: review
description: Revisar los cambios preparados en busca de problemas
allowed-tools:
  - read
  - grep
  - glob
  - exec
permissions:
  allow:
    - Exec(git diff)
    - Exec(git log)
---

Ejecuta `git diff --staged` y revisa los cambios en busca de problemas de calidad.

Evalúa:
1. **Corrección** — ¿Algún error lógico o casos límite?
2. **Seguridad** — ¿Se introdujo alguna vulnerabilidad?
3. **Rendimiento** — ¿Alguna ineficiencia obvia?
4. **Estilo** — ¿Consistente con el código base?

Proporciona un resumen con referencias específicas a las líneas.
```

<div id="component-generator">
  ### Generador de componentes
</div>

```markdown theme={null}
---
name: component
description: Generar un componente de React a partir de una descripción
argument-hint: "<ComponentName>"
allowed-tools:
  - read
  - edit
  - grep
  - glob
model: sonnet
permissions:
  allow:
    - Write(src/components/**)
---

Crear un nuevo componente de React usando el nombre que proporciona el usuario:

1. Revisar los componentes existentes en src/components/ para conocer las convenciones de estilo
2. Crear el archivo del componente en src/components/<ComponentName>/<ComponentName>.tsx
3. Crear una exportación barrel en src/components/<ComponentName>/index.ts
4. Agregar pruebas básicas en src/components/<ComponentName>/<ComponentName>.test.tsx
5. Seguir los patrones que encuentres en los componentes existentes
```

<div id="deployment-checklist">
  ### Lista de verificación de despliegue
</div>

```markdown theme={null}
---
name: deploy
description: Run through the deployment checklist
triggers:
  - user
allowed-tools:
  - read
  - exec
  - grep
permissions:
  allow:
    - Exec(npm run)
    - Exec(git)
---

Run through the deployment checklist:

1. Run the test suite: `npm run test`
2. Run the linter: `npm run lint`
3. Check for uncommitted changes: `git status`
4. Verify the build: `npm run build`
5. Show the current branch and last commit

Report the status of each step. If anything fails, stop and explain the issue.
```

<div id="search-expert">
  ### Experto en búsquedas
</div>

```markdown theme={null}
---
name: find
description: Find relevant code across the project
argument-hint: "<what to find>"
allowed-tools:
  - read
  - grep
  - glob
triggers:
  - user
  - model
---

Busca exhaustivamente en el código base lo que el usuario preguntó.

Usa grep para buscar contenido y glob para descubrir archivos.
Proporciona rutas de archivos relevantes y fragmentos de código.
Explica cómo se conectan las piezas.
```

***

<div id="tips">
  ## Consejos
</div>

<CardGroup cols={2}>
  <Card title="Mantén los prompts enfocados" icon="bullseye">
    Una skill debe hacer una sola cosa bien. Crea múltiples skills en lugar de una mega-skill.
  </Card>

  <Card title="Incluye ejemplos" icon="lightbulb">
    Muestra al agente en tu prompt cómo es una buena salida.
  </Card>

  <Card title="Usa allowed-tools" icon="shield">
    Restringir las herramientas hace que las skills sean más seguras y predecibles.
  </Card>

  <Card title="Prueba con /skill-name" icon="play">
    Invoca tu skill y ajusta el prompt hasta obtener la salida que quieres.
  </Card>
</CardGroup>