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

> Le skill aiutano Cascade a gestire attività complesse e articolate in più passaggi.

Le attività di ingegneria più complesse spesso richiedono più di semplici buoni prompt. Possono richiedere script di riferimento, modelli, checklist e altri file di supporto. Le skill consentono di raggruppare tutto questo in cartelle che Cascade può invocare (leggere e utilizzare).

Le skill sono un ottimo modo per insegnare a Cascade a eseguire flussi di lavoro articolati in più passaggi in modo coerente.

Cascade usa la [**progressive disclosure**](https://agentskills.io/what-are-skills#how-skills-work): per impostazione predefinita, al modello vengono mostrati solo `name` e `description` della skill. Il contenuto completo di `SKILL.md` e i file di supporto vengono caricati **solo quando Cascade decide di invocare la skill** (o quando la citi con `@`). In questo modo, la finestra di contesto resta snella anche con molte skill definite.

Per maggiori dettagli sulla specifica delle Skills, visita [agentskills.io](https://agentskills.io/home).

<div id="how-to-create-a-skill">
  ## Come creare una skill
</div>

<div id="using-the-ui-easiest">
  ### Tramite la UI (più semplice)
</div>

1. Apri il pannello Cascade
2. Fai clic sui tre puntini in alto a destra del pannello per aprire il menu di personalizzazione
3. Fai clic sulla sezione `Skills`
4. Fai clic su `+ Workspace` per creare una skill del workspace (specifica del progetto) oppure su `+ Global` per creare una skill globale
5. Assegna un nome alla skill (solo lettere minuscole, numeri e trattini)

<div id="manual-creation">
  ### Creazione manuale
</div>

**Skill del workspace (specifica del progetto):**

1. Crea una directory: `.windsurf/skills/<skill-name>/`
2. Aggiungi un file `SKILL.md` con frontmatter YAML

**Skill globale (disponibile in tutti i workspace):**

1. Crea una directory: `~/.codeium/windsurf/skills/<skill-name>/`
2. Aggiungi un file `SKILL.md` con frontmatter YAML

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

Ogni skill richiede un file `SKILL.md` con frontmatter YAML che contiene i metadati della skill:

<div id="example-skill">
  ### Esempio di skill
</div>

```markdown theme={null}
---
name: deploy-to-production
description: Guida il processo di distribuzione in produzione con controlli di sicurezza
---

## Lista di controllo pre-distribuzione
1. Esegui tutti i test
2. Controlla le modifiche non salvate
3. Verifica le variabili d'ambiente

## Fasi di distribuzione
Segui questi passaggi per distribuire in modo sicuro...

[Fai riferimento ai file di supporto in questa directory secondo necessità]
```

<div id="required-frontmatter-fields">
  ### Campi obbligatori del frontmatter
</div>

* **name**: Identificatore univoco della skill (visualizzato nella UI e usato per le menzioni con @)
* **description**: Breve descrizione mostrata al modello per aiutarlo a decidere quando invocare la skill

Esempi di nomi validi: `deploy-to-staging`, `code-review`, `setup-dev-environment`

<div id="adding-supporting-resources">
  ## Aggiungere risorse di supporto
</div>

Colloca eventuali file di supporto nella cartella della skill, accanto a `SKILL.md`. Questi file saranno disponibili per Cascade quando la skill viene invocata:

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

<div id="invoking-skills">
  ## Richiamo delle skill
</div>

<div id="automatic-invocation">
  ### Invocazione automatica
</div>

Quando la tua richiesta corrisponde alla descrizione di una skill, Cascade invoca automaticamente la skill e usa le relative istruzioni e risorse per completare l'attività. Questo è il modo più comune in cui vengono usate le skill: ti basta descrivere ciò che vuoi fare e Cascade individua quali skill sono pertinenti.

Il campo `description` nel frontmatter della tua skill è fondamentale: aiuta Cascade a capire quando invocare la skill. Scrivi descrizioni che spieghino chiaramente cosa fa la skill e quando va usata.

<div id="manual-invocation">
  ### Invocazione manuale
</div>

Puoi sempre attivare esplicitamente una skill digitando `@skill-name` nel campo di input di Cascade. Questo è utile quando vuoi assicurarti che venga usata una skill specifica o quando vuoi invocare una skill che potrebbe non essere attivata automaticamente dalla tua richiesta.

<div id="skill-scopes">
  ## Ambiti delle skill
</div>

| Ambito               | Posizione                                    | Disponibilità                                                   |
| -------------------- | -------------------------------------------- | --------------------------------------------------------------- |
| Workspace            | `.windsurf/skills/`                          | Solo nel workspace corrente. Incluso nei commit della tua repo. |
| Globale              | `~/.codeium/windsurf/skills/`                | Tutti i workspace sulla tua macchina. Non incluso nei commit.   |
| Sistema (Enterprise) | Specifico del sistema operativo (vedi sotto) | Tutti i workspace, distribuito dall'IT. Sola lettura.           |

<Note>
  Per la compatibilità tra agenti, Devin Desktop rileva anche le skill in `.agents/skills/` e `~/.agents/skills/`. Se hai abilitato la lettura della configurazione di Claude Code, vengono analizzate anche `.claude/skills/` e `~/.claude/skills/`.
</Note>

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

Le organizzazioni Enterprise possono distribuire skill disponibili in tutti i workspace e non modificabili dagli utenti finali:

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

Ogni skill è una sottodirectory che contiene un file `SKILL.md`, proprio come le skill del workspace.

<div id="example-use-cases">
  ## Esempi di casi d'uso
</div>

<div id="deployment-workflow">
  ### Flusso di lavoro di distribuzione
</div>

Crea una skill con script di distribuzione, configurazioni di ambiente e procedure di rollback:

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

<div id="code-review-guidelines">
  ### Linee guida per la revisione del codice
</div>

Includi guide di stile, checklist di sicurezza e modelli per la revisione:

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

<div id="testing-procedures">
  ### Procedure di testing
</div>

Raggruppa i template di test, i requisiti di copertura e le configurazioni CI/CD:

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

<div id="best-practices">
  ## Buone pratiche
</div>

1. **Scrivi descrizioni chiare**: La descrizione aiuta Cascade a decidere quando invocare la skill. Sii specifico su cosa fa la skill e su quando dovrebbe essere utilizzata.

2. **Includi risorse pertinenti**: Template, checklist ed esempi rendono le skill più utili. Pensa a quali file potrebbero aiutare qualcuno a completare l'attività.

3. **Usa nomi descrittivi**: `deploy-to-staging` è meglio di `deploy1`. I nomi devono indicare chiaramente cosa fa la skill.

<div id="skills-vs-rules-vs-workflows">
  ## Skills vs Regole vs Flussi di lavoro
</div>

Tutti e tre personalizzano Cascade, ma differiscono per **struttura**, **invocazione** e **costo del contesto**:

|                            | Skills                                                                                                | Regole                                             | Flussi di lavoro                             |
| -------------------------- | ----------------------------------------------------------------------------------------------------- | -------------------------------------------------- | -------------------------------------------- |
| **Scopo**                  | Procedure in più passaggi con file di supporto                                                        | Linee guida comportamentali ("come comportarsi")   | Template di prompt per attività ripetibili   |
| **Struttura**              | Cartella con `SKILL.md` + eventuali file di risorse                                                   | Singolo file `.md` con frontmatter                 | Singolo file `.md`                           |
| **Invocazione**            | Decide il modello (disclosure progressiva) oppure `@mention`                                          | `always_on` / `glob` / `model_decision` / `manual` | **Solo manuale** tramite `/slash-command`    |
| **Nel prompt di sistema?** | No — solo nome + descrizione fino all'invocazione                                                     | Dipende dalla modalità di attivazione              | No — elencati come comandi disponibili       |
| **Ideale per**             | Distribuzioni, procedure di revisione del codice, procedure di testing che richiedono script/template | Stile di codice, convenzioni di progetto, vincoli  | Runbook una tantum che attivi esplicitamente |

**Regola pratica:** se Cascade deve selezionarlo automaticamente *e* sono necessari file di supporto, usa una Skill. Se è un breve vincolo comportamentale, usa una Regola. Se vuoi sempre attivarlo tu, usa un Flusso di lavoro.

<div id="related-documentation">
  ## Documentazione correlata
</div>

Se Skills non è ciò che stai cercando, dai un'occhiata a queste altre funzionalità di Cascade:

* **[Flussi di lavoro](./workflows)** - Automatizza le attività ripetitive con flussi di lavoro markdown riutilizzabili richiamati tramite slash command
* **[AGENTS.md](./agents-md)** - Definisci istruzioni valide a livello di directory che si applicano automaticamente in base alla posizione del file
* **[Memories & Regole](./memories)** - Mantieni il contesto tra le conversazioni con memorie generate automaticamente e regole definite dall'utente