> ## Documentation Index > Fetch the complete documentation index at: https://docs.devinenterprise.com/llms.txt > Use this file to discover all available pages before exploring further. # Skill > Insegna a Devin procedure riutilizzabili effettuando il commit di file SKILL.md nei tuoi repo
## Cosa sono le Skills?
Le Skills sono file `SKILL.md` che aggiungi ai tuoi repository e che insegnano a Devin **procedure riutilizzabili** — qualsiasi flusso di lavoro ripetibile che vuoi che Devin segua in modo coerente. Testare la tua app prima di aprire una PR, distribuire in un ambiente, analizzare una codebase, creare lo scaffolding di un nuovo servizio — se puoi scriverlo come istruzioni passo dopo passo, puoi trasformarlo in una skill. Seguono lo standard aperto [Agent Skills](https://agentskills.io/specification), quindi gli stessi file di Skill funzionano su più strumenti di sviluppo basati sull'AI. Posiziona i file di Skill in `.agents/skills//SKILL.md` nel tuo repository. Devin li rileva automaticamente in tutti i repository che hai collegato. Consulta la [specifica di Agent Skills](https://agentskills.io/specification) per il riferimento completo al formato del file.
## Perché le Skills sono importanti
Senza Skills, Devin deve capire i flussi di lavoro da zero a ogni sessione. Con le Skills, definisci una procedura una sola volta e Devin la segue in modo affidabile ogni volta. Le Skills sono utili ogni volta che hai un flusso di lavoro che: * **Deve essere eseguito sempre allo stesso modo** — checklist di test, passaggi di deployment, procedure di revisione * **Richiede conoscenze specifiche del repo** — quali servizi avviare, quali porte usare, quali comandi eseguire * **Trae vantaggio da un contesto dinamico** — recuperando diff di Git, nomi di branch o informazioni sull'ambiente al momento dell'invocazione
## Devin suggerisce automaticamente le skill
Devin può suggerirti automaticamente delle skill. Dopo che Devin ha testato la tua applicazione o ha imparato qualcosa di nuovo sulla tua configurazione durante una sessione, ti suggerirà di creare o aggiornare una skill per catturare queste informazioni. Vedrai un suggerimento nella cronologia della tua sessione con: * Un riepilogo di ciò che è stato appreso (ad es. "come avviare il backend con Docker") * Il contenuto proposto del file `SKILL.md` * Un pulsante **"Create PR"** per fare il commit della skill nel tuo repository Nel tempo, Devin costruisce nel tuo repository una libreria di skill su come eseguire, testare e distribuire la tua applicazione.
## Esempi
### Test prima di aprire una PR
Una skill che istruisce Devin su come verificare un'app Next.js prima di creare una pull request: ```markdown theme={null} --- name: test-before-pr description: Run the local dev server and verify pages before opening any PR that touches frontend code. --- ## Setup 1. Install dependencies: `npm install` 2. Start the database: `docker-compose up -d postgres` 3. Run migrations: `npx prisma migrate dev` 4. Start the dev server: `npm run dev` 5. Wait for "Ready on http://localhost:3000" ## Verify 1. Read the git diff to identify which pages changed 2. Open each affected page in the browser 3. Check for: console errors, layout issues, broken links 4. Screenshot each page at desktop (1280px) and mobile (375px) widths ## Before Opening the PR 1. Run `npm run lint` and fix any issues 2. Run `npm test` and confirm all tests pass 3. Include screenshots in the PR description ```
### Distribuire in un ambiente
Una skill che esegue il deployment dell'app usando argomenti per l'ambiente di destinazione, con iniezione dinamica di contenuti: ```markdown theme={null} --- name: deploy description: Distribuisci l'app in un ambiente di destinazione ed esegui smoke test. argument-hint: triggers: ["user"] --- ## Deploy 1. Assicurati di essere sul branch corretto per questo deploy 2. Run `./scripts/deploy.sh $0` 3. Attendi il completamento con successo dello script di deploy ## Verify 1. Esegui Curl su `https://$0.example.com/health` e conferma una risposta 200 2. Run the smoke test suite: `npm run test:smoke -- --env=$0` 3. Riporta l'URL di deployment e i risultati dei test ## Contesto attuale - Branch: !`git branch --show-current` - Last commit: !`git log --oneline -1` ``` Invocando `@skills:deploy staging`, `staging` viene sostituito a `$ARGUMENTS` e `$0`, e i blocchi `` !`command` `` inseriscono informazioni git in tempo reale. Il campo `triggers: ["user"]` garantisce che Devin esegua questa skill solo quando lo richiedi esplicitamente — non si attiverà automaticamente.
### Analisi di una parte del codebase
Una skill per l'esplorazione guidata del codice che limita Devin agli strumenti in sola lettura: ```markdown theme={null} --- name: investigate description: Research a part of the codebase and produce a written summary with file references. allowed-tools: Read, Grep, ListDir argument-hint: --- ## Research 1. Search the codebase for files related to: $ARGUMENTS 2. Read the most relevant files thoroughly 3. Trace the call chain and data flow ## Summarize 1. Write a summary of how $ARGUMENTS works 2. Include specific file paths and line numbers for every claim 3. Note any concerns, edge cases, or areas that need attention ``` Il campo `allowed-tools` limita Devin a operazioni di sola lettura — nessuna modifica, nessun comando shell. Questo è utile per attività esplorative in cui si vuole un'analisi senza effetti collaterali.
## Scoperta delle skill
Devin individua le skill da **due fonti**, unite all'inizio di ogni sessione: 1. **Repository indicizzati** — il backend di Devin indicizza i file `SKILL.md` in tutti i repository collegati alla tua organizzazione. Questi sono disponibili immediatamente all'avvio di una sessione, prima che qualsiasi repository venga clonato. 2. **Repository clonati** — man mano che i repository vengono clonati sulla macchina della sessione, Devin li analizza alla ricerca di file `SKILL.md` su disco. Le skill rilevate su disco aggiornano o sovrascrivono qualsiasi skill indicizzata corrispondente dallo stesso repository, garantendo che Devin utilizzi sempre la versione più recente sul branch su cui si sta lavorando. Quando la clonazione di un repository si completa durante una sessione, Devin esegue automaticamente una nuova scansione di quel repository, così le skill appena aggiunte o modificate vengono rilevate senza dover riavviare.
### Posizioni supportate per i file skill
Devin cerca i file `SKILL.md` in tutte le directory seguenti: * `.agents/skills//SKILL.md` **(consigliato)** * `.devin/skills//SKILL.md` * `.github/skills//SKILL.md` * `.claude/skills//SKILL.md` * `.cursor/skills//SKILL.md` * `.codex/skills//SKILL.md` * `.cognition/skills//SKILL.md` * `.windsurf/skills//SKILL.md` Tutti e otto i percorsi vengono sottoposti a scansione in ogni repository.
### Cosa carica Devin da un file di skill
Quando una skill viene rilevata, Devin analizza il **frontmatter** YAML (il blocco `---` all'inizio) ed estrae: | Field | Purpose | | --------------- | ----------------------------------------------------------------------------------------- | | `name` | Identifica la skill. Se omesso, viene usato il nome della directory padre. | | `description` | Breve riepilogo mostrato nell'elenco delle skill, così Devin (e tu) sai cosa fa la skill. | | `allowed-tools` | Limita quali strumenti Devin può usare mentre la skill è attiva. | Devin supporta anche questi campi di frontmatter aggiuntivi oltre alla specifica standard: | Field | Purpose | | --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `argument-hint` | Testo di suggerimento mostrato accanto al nome della skill che descrive gli argomenti attesi. | | `triggers` | Controlla chi può invocare la skill — `["user", "model"]` per impostazione predefinita. Impostalo a `["user"]` per evitarne l'auto-attivazione da parte di Devin. | Tutto ciò che viene **dopo** il frontmatter è il corpo della skill — le istruzioni passo-passo che Devin deve seguire quando la skill viene invocata. Consulta la [specifica di Agent Skills](https://agentskills.io/specification) per il riferimento completo al formato del file.
## Come Devin usa le skill
All'inizio di ogni sessione, Devin vede un elenco di tutte le skill disponibili (nome e descrizione). Quando una skill viene **invocata**, Devin legge l'intero file `SKILL.md` e inserisce il suo contenuto nel proprio contesto corrente come istruzione a livello di sistema. Ciò significa che Devin segue attivamente i passaggi definiti dalla skill per il resto dell'attività — non si tratta solo di un riferimento, ma guida direttamente il comportamento di Devin. Devin può utilizzare le skill in diversi modi:
### Invocazione automatica
Quando Devin stabilisce che una skill è rilevante per l'attività corrente, la esegue automaticamente. Ad esempio, se chiedi a Devin di correggere un bug nel codice frontend e c'è una skill `test-before-pr`, Devin la attiverà prima di aprire la PR. Imposta `triggers: ["user"]` nel frontmatter per impedire l'invocazione automatica per le skill che vuoi attivare solo esplicitamente.
### Menziona una skill nel tuo prompt
Puoi chiedere a Devin di usare una skill specifica includendo `@skills:skill-name` nel tuo messaggio: ``` Fix the login bug on the /auth page @skills:test-before-pr ``` È anche possibile passare argomenti: ``` @skills:deploy staging ``` Gli argomenti vengono sostituiti nel corpo della skill ovunque siano presenti `$ARGUMENTS`, `$ARGUMENTS[0]`, `$1`, ecc.
### Una sola skill attiva alla volta
Devin può avere una sola skill attiva alla volta. L'attivazione di una nuova skill sostituisce quella precedente. Quando una skill è attiva, Devin segue i passaggi della skill in ordine, completando ciascuno di essi prima di passare al successivo.
### Ricerca ed elenco
Devin può cercare le skill per parola chiave o per directory se deve trovare quella giusta nel corso di una sessione. Puoi anche chiedere a Devin di elencare le skill disponibili o di ricaricarle dopo aver fatto push delle modifiche a un file di skill.
## Limitazioni
* **Competenze globali / a livello di organizzazione** — Attualmente, le competenze risiedono all'interno dei repository. Per avere competenze a livello di organizzazione, puoi creare un repository dedicato alle "competenze" come soluzione alternativa. Stiamo valutando un supporto di prima classe per competenze a livello di organizzazione che si applichino a tutti i repository. * **Composizione di più competenze** — Al momento può essere attiva solo una competenza alla volta. Stiamo lavorando al supporto per concatenare e comporre workflow.
## Skill vs. Playbook
Sia le skill che i [playbook](/it/product-guides/creating-playbooks) forniscono a Devin istruzioni riutilizzabili, ma funzionano in modo diverso: | | Skills | Playbooks | | --------------------------- | ----------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | | **Dove si trovano** | Nel tuo repo come file `SKILL.md` — sotto controllo di versione insieme al tuo codice | Nella web app di Devin — gestiti tramite l'interfaccia utente | | **Come vengono attivati** | Devin le scopre e le invoca automaticamente, oppure puoi richiamarle con `@skills:name` in qualsiasi prompt | Collegati manualmente a una sessione quando la avvii | | **Ambito** | Limitate a un repo — Devin rileva le skill giuste in base ai repo rilevanti per l'attività | A livello di organizzazione — qualsiasi membro del team può collegare qualsiasi playbook a qualsiasi sessione | | **Suggerimento automatico** | Devin suggerisce nuove skill dopo aver testato la tua app o aver appreso qualcosa di nuovo | Creati manualmente dai membri del team | | **Ideali per** | Procedure di test, configurazioni di sviluppo locale, checklist di deployment, workflow specifici del repo | Template di prompt riutilizzabili, modelli di attività tra più repo, guide di onboarding | **Quale dovrei usare?** Se le tue istruzioni sono legate a uno specifico repo — come eseguirlo, testarlo o effettuare il deployment — usa una skill. Se le tue istruzioni sono prompt generici che si applicano a più repo o team, usa un playbook.
## Per saperne di più
* [Agent Skills specification](https://agentskills.io/specification) — lo standard aperto per il formato del file `SKILL.md`, i campi di front matter e la struttura delle directory * [Knowledge](/it/product-guides/knowledge) — per suggerimenti e informazioni di contesto (non procedure dettagliate passo passo) * [Playbooks](/it/product-guides/creating-playbooks) — per modelli di prompt riutilizzabili associati alle sessioni