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

# Creazione di Skills

> Riferimento completo per il formato `SKILL.md` e le opzioni del frontmatter

Le Skills sono definite come file `SKILL.md` all'interno di una directory con un nome specifico. Questa pagina illustra tutto ciò che devi sapere per scrivere skills efficaci.

***

<div id="file-structure">
  ## Struttura dei file
</div>

Colloca le skills nella directory appropriata in base all'ambito:

```
# Specifico del progetto (commit su git)
.devin/skills/
└── my-skill/
    └── SKILL.md

# Globale — disponibile in tutti i progetti (non in commit)
# Linux/macOS:
~/.config/devin/skills/
└── my-skill/
    └── SKILL.md

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

Il nome della directory è l'identificatore della skill (usato per richiamare `/my-skill`). Il file `SKILL.md` contiene un frontmatter YAML facoltativo e il contenuto del prompt della skill.

<Note>
  Su Windows, `%APPDATA%` corrisponde in genere a `C:\Users\<YourUser>\AppData\Roaming`.
</Note>

***

<div id="frontmatter-reference">
  ## Riferimento del 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">
  ### Tutti i campi del frontmatter
</div>

| Campo           | Tipo    | Predefinito          | Descrizione                                                                                                             |
| --------------- | ------- | -------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| `name`          | string  | nome della directory | Nome visualizzato della skill                                                                                           |
| `description`   | string  | nessuno              | Mostrata nei completamenti degli Slash Command                                                                          |
| `argument-hint` | string  | nessuno              | Suggerimento mostrato dopo il nome del comando (ad es. `[filename]`)                                                    |
| `model`         | string  | modello corrente     | Sovrascrive il modello usato per eseguire questa skill                                                                  |
| `subagent`      | boolean | `false`              | Esegue la skill come [subagent](/it/cli/subagents) invece che inline                                                    |
| `agent`         | string  | nessuno              | Esegue la skill come subagent usando un profilo [subagent personalizzato](/it/cli/subagents#custom-subagents) specifico |
| `allowed-tools` | lista   | tutti gli strumenti  | Limita gli strumenti che la skill può usare                                                                             |
| `permissions`   | oggetto | eredita              | Sovrascritture delle autorizzazioni per questa skill                                                                    |
| `triggers`      | lista   | `[user, model]`      | Come può essere invocata la skill                                                                                       |

***

<div id="model-override">
  ## Override del modello
</div>

Usa il campo `model` per eseguire una skill con un modello diverso da quello attivo nella sessione corrente. È utile se vuoi usare un modello più rapido per attività semplici o uno più potente per quelle complesse:

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

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

Il nome del modello utilizza gli stessi valori del flag CLI `--model` (ad es. `opus`, `sonnet`, `swe`, `codex`). Consulta [Models](/it/cli/models) per l'elenco completo. Una volta completata la skill, la sessione torna al modello precedentemente attivo.

***

<div id="running-skills-as-subagents">
  ## Eseguire le skill come subagent
</div>

<Warning>
  L'esecuzione delle skill come subagent è **sperimentale**. I campi `subagent` e `agent` del frontmatter potrebbero cambiare nelle versioni future.
</Warning>

Per impostazione predefinita, il prompt di una skill viene iniettato nella conversazione corrente e l'agente lo elabora inline. In alternativa, puoi eseguire una skill come **subagent**, che avvia un processo indipendente con una propria finestra di contesto. Questa opzione è utile per skill che svolgono attività mirate e autonome, quando non vuoi che l'output appesantisca la conversazione principale.

Esistono due modi per eseguire una skill come subagent:

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

Imposta `subagent: true` per eseguire la skill come subagent usando il profilo predefinito `subagent_general`:

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

Quando viene invocata, questa skill avvia un subagent in foreground che esegue il prompt della skill come attività. L'agent principale attende che il subagent termini, quindi ne legge e riassume i risultati.

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

Utilizza il campo `agent` per eseguire la skill come subagent con un [profilo personalizzato del subagent](/it/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.
```

Il valore `agent` deve corrispondere al nome di un profilo subagent registrato (integrato, come `subagent_explore` / `subagent_general`, oppure un profilo personalizzato che hai definito). Il subagent eredita il system prompt del profilo, le restrizioni sugli strumenti e il modello, mentre il contenuto della skill diventa l'attività.

<Note>
  Se sono impostati sia `agent` sia `subagent`, `agent` ha la precedenza. Il campo `model` della skill esegue l'override del modello del profilo subagent quando sono specificati entrambi.
</Note>

<Note>
  Le skill eseguite come subagent non generano subagent nidificati: se la skill è già in esecuzione all'interno di un subagent, viene invece eseguita inline per evitare una ricorsione infinita.
</Note>

<div id="orchestrating-subagents-using-skills">
  ### Orchestrare i subagenti con le skill
</div>

Poiché le skill possono essere eseguite come subagenti, puoi usarle per orchestrare attività articolate in più passaggi. Definisci un insieme di skill di subagent, ciascuna dedicata a un'attività specifica, quindi scrivi una normale skill che le invochi. La skill esterna diventa l'orchestratore: richiama ogni subagent, raccoglie i risultati e decide cosa fare successivamente.

Ad esempio, ecco due skill di subagent e un orchestratore che le 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
```

Invocare `/health-check` esegue l'orchestratore nell'agente principale. Questo richiama `/research-changes`, che genera un subagent per esplorare la repo. Una volta completato, richiama `/validate-tests`, che genera un altro subagent per eseguire i test. L'orchestratore sintetizza quindi entrambi i risultati in un riepilogo finale.

Una skill di un subagent **non** utilizza **mai** un subagent quando richiama altre skill, anche se queste hanno `subagent: true`: vengono invece eseguite inline. Questo significa che non devi preoccuparti di un annidamento illimitato. Il modello di orchestrazione ha sempre un solo livello di profondità: l'orchestratore genera i subagent e questi eseguono tutto il resto inline.

***

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

Il contenuto del file SKILL.md (dopo il frontmatter) è il prompt che viene aggiunto quando la skill viene invocata.

***

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

Le Skills possono definire il proprio ambito di autorizzazione usando la stessa sintassi della configurazione principale delle autorizzazioni:

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

**Come funzionano le autorizzazioni delle skill:**

* `allow` — Questi ambiti vengono approvati automaticamente durante l'esecuzione della skill
* `deny` — Questi ambiti vengono bloccati durante l'esecuzione della skill
* `ask` — Questi ambiti richiedono sempre la conferma dell'utente

<Note>
  Le autorizzazioni delle skill sono cumulative rispetto alle autorizzazioni di base della sessione (non le sostituiscono). Una skill non può concedere autorizzazioni negate a un livello superiore (configurazione del progetto o dell'organizzazione).
</Note>

***

<div id="allowed-tools">
  ## Strumenti consentiti
</div>

Limita gli strumenti che la skill può usare:

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

Nomi dei tool disponibili: `read`, `edit`, `grep`, `glob`, `exec`

Puoi anche consentire i tool MCP:

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

<Warning>
  Se `allowed-tools` non è specificato, la skill ha accesso a tutti gli strumenti. Per le skill critiche dal punto di vista della sicurezza, limita sempre l'accesso al minimo necessario.
</Warning>

***

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

<div id="code-review-skill">
  ### Skill per la revisione del codice
</div>

```markdown theme={null}
---
name: review
description: Revisiona le modifiche in staging per problemi
allowed-tools:
  - read
  - grep
  - glob
  - exec
permissions:
  allow:
    - Exec(git diff)
    - Exec(git log)
---

Esegui `git diff --staged` e revisiona le modifiche per problemi di qualità.

Valuta:
1. **Correttezza** — Errori logici o casi limite?
2. **Sicurezza** — Vulnerabilità introdotte?
3. **Prestazioni** — Inefficienze evidenti?
4. **Stile** — Coerente con il codebase?

Fornisci un riepilogo con riferimenti specifici alle righe.
```

<div id="component-generator">
  ### Generatore di componenti
</div>

```markdown theme={null}
---
name: component
description: Generate a React component from a description
argument-hint: "<ComponentName>"
allowed-tools:
  - read
  - edit
  - grep
  - glob
model: sonnet
permissions:
  allow:
    - Write(src/components/**)
---

Create a new React component using the name the user provides:

1. Check existing components in src/components/ for style conventions
2. Create the component file at src/components/<ComponentName>/<ComponentName>.tsx
3. Create a barrel export at src/components/<ComponentName>/index.ts
4. Add basic tests at src/components/<ComponentName>/<ComponentName>.test.tsx
5. Follow the patterns you find in existing components
```

<div id="deployment-checklist">
  ### Checklist per la distribuzione
</div>

```markdown theme={null}
---
name: deploy
description: Esegui la checklist di distribuzione
triggers:
  - user
allowed-tools:
  - read
  - exec
  - grep
permissions:
  allow:
    - Exec(npm run)
    - Exec(git)
---

Esegui la checklist di distribuzione:

1. Esegui la suite di test: `npm run test`
2. Esegui il linter: `npm run lint`
3. Verifica le modifiche non committate: `git status`
4. Verifica la build: `npm run build`
5. Mostra il branch corrente e l'ultimo commit

Riporta lo stato di ogni passaggio. Se qualcosa fallisce, interrompi e spiega il problema.
```

<div id="search-expert">
  ### Esperto di ricerca
</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
---

Search the codebase thoroughly for what the user asked about.

Use grep for content search and glob for file discovery.
Provide relevant file paths and code snippets.
Explain how the pieces connect.
```

***

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

<CardGroup cols={2}>
  <Card title="Mantieni i prompt focalizzati" icon="bullseye">
    Una skill dovrebbe fare bene una sola cosa. Crea più skill invece di un'unica mega-skill.
  </Card>

  <Card title="Includi esempi" icon="lightbulb">
    Nel prompt, mostra all'agente che aspetto dovrebbe avere un buon output.
  </Card>

  <Card title="Usa allowed-tools" icon="shield">
    Limitare i tool rende le skill più sicure e prevedibili.
  </Card>

  <Card title="Prova con /skill-name" icon="play">
    Invoca la tua skill e perfeziona il prompt finché l'output non è quello che vuoi.
  </Card>
</CardGroup>