# Skills (/it/docs/verdent-manager/core-features/skills)
> Estendi le capacità di Verdent con pacchetti di conoscenza riutilizzabili per flussi di lavoro specializzati e competenze di dominio
Le **Skills** di Verdent sono pacchetti di conoscenza riutilizzabili che estendono le competenze dell'agente. Ogni Skill contiene prompt specifici del dominio, script, riferimenti e best practice. Basta invocare una Skill per nome e l'agente carica il contesto corrispondente seguendo il flusso di lavoro predefinito.
***
## Cosa sono le Skills? [#cosa-sono-le-skills]
### Concetto di base [#concetto-di-base]
Una **Skill** è un pacchetto di conoscenza strutturato memorizzato in una cartella. Ogni Skill contiene un file `SKILL.md` che ne definisce il nome, la descrizione e il prompt dettagliato. Quando invochi una Skill in una conversazione, Verdent legge questo file e ne inserisce il contenuto nel contesto dell'agente.
### Differenze tra Skills, sottoagenti e MCP [#differenze-tra-skills-sottoagenti-e-mcp]
| Dimensione | Skills | Sottoagenti | MCP |
| ------------------- | -------------------------------------------------- | ------------------------------------------------------------------ | ----------------------------------------------------------- |
| **Attivazione** | Invocazione manuale tramite `@skill` o menzione | Generati automaticamente dall'agente principale | Invocati automaticamente o chiamati esplicitamente |
| **Esecuzione** | Espande il contesto della conversazione principale | Eseguiti come sotto-attività indipendente con contesto isolato | Chiamano strumenti esterni tramite JSON-RPC 2.0 |
| **Scopo** | Guida di dominio (ad es. "come scrivere test") | Operazioni indipendenti (ad es. "esegui una revisione del codice") | Accesso a dati/strumenti esterni (ad es. query su database) |
| **Ciclo di vita** | Iniezione di contesto una tantum | Completa la sotto-attività e restituisce i risultati | Processo server persistente durante la sessione |
| **Implementazione** | File Markdown + script opzionali | Logica integrata dell'agente | Processi server eseguibili |
In sintesi: **le Skills forniscono conoscenza e guida sui flussi di lavoro**, **i sottoagenti eseguono attività indipendenti** e **MCP collega strumenti e fonti di dati esterne**.
***
## Come usare le Skills [#come-usare-le-skills]
### Invocare una Skill [#invocare-una-skill]
Puoi invocare una Skill in due modi:
**1. Menziona il nome della Skill nella conversazione**
```
Use the skill-creator skill to help me create a new Skill
```
**2. Usa la sintassi di menzione @**
```
@skill-creator help me create a Skill for API documentation generation
```
Quando una Skill viene attivata:
1. L'agente chiama lo strumento `skill` per leggere il file `SKILL.md` della Skill
2. Il contenuto del file viene inserito nel contesto della conversazione corrente
3. L'agente prosegue il lavoro seguendo la guida della Skill
### Sfogliare le Skills disponibili [#sfogliare-le-skills-disponibili]
Accedi al pannello Skills tramite le impostazioni:
1. Apri il menu **Settings**
2. Seleziona la scheda **Skills**
3. Sfoglia le Skills installate e quelle disponibili nello Skill Store
Puoi anche digitare `@` nella casella di input per attivare il completamento automatico e selezionare rapidamente una Skill disponibile.
***
## Skills integrate [#skills-integrate]
Verdent include un insieme di Skills integrate che coprono i flussi di lavoro più comuni:
| Skill | Descrizione |
| ------------------- | --------------------------------------------------------------------------------------- |
| **docx** | Leggi, crea o modifica documenti Word (`.docx`) con verifiche visive fedeli al formato |
| **find-skills** | Scopri e installa Skills — utile quando chiedi "come faccio X?" o cerchi nuove capacità |
| **frontend-design** | Crea interfacce frontend distintive e di livello produttivo con alta qualità di design |
| **pdf** | Leggi, crea o rivedi file PDF con rendering visivo ed estrazione dei contenuti |
| **pptx** | Leggi, crea o modifica presentazioni PowerPoint (`.pptx`) |
| **skill-creator** | Un flusso di lavoro guidato per creare e iterare su Skills personalizzate |
| **xlsx** | Leggi, analizza, visualizza e modifica in modo intelligente fogli di calcolo Excel |
Altre Skills sono disponibili nello **Skill Store**. Apri **Settings → Skills → Store** per sfogliarle e installarne altre.
***
## Creare Skills personalizzate [#creare-skills-personalizzate]
Puoi creare Skills personalizzate per racchiudere le competenze di dominio del tuo team o i flussi di lavoro specifici del progetto.
### Struttura della cartella di una Skill [#struttura-della-cartella-di-una-skill]
Una cartella Skill standard ha questo aspetto:
```
my-custom-skill/
├── SKILL.md # Required: Skill definition file
├── agents/
│ └── verdent.yaml # Optional: UI configuration (icons, display name)
├── scripts/ # Optional: helper scripts
└── references/ # Optional: reference docs or examples
```
### Formato di SKILL.md [#formato-di-skillmd]
`SKILL.md` è il file principale della Skill e contiene un frontmatter YAML e un corpo Markdown:
```markdown
---
name: my-custom-skill
description: A concise description shown in the Skill list
metadata:
version: "1.0.0"
author: "Your Name"
license: "MIT"
---
# Detailed Instructions
This is the detailed prompt content the Agent reads.
## Workflow
1. Step one
2. Step two
3. ...
## Best Practices
- Practice suggestion 1
- Practice suggestion 2
```
**Requisiti dei campi del frontmatter:**
* `name` (obbligatorio): deve corrispondere al nome della cartella. Sono ammessi solo lettere minuscole, numeri e trattini (`a-z0-9-`). Lunghezza: 1–64 caratteri. Niente trattini consecutivi né trattini iniziali o finali.
* `description` (obbligatorio): una breve descrizione, massimo 1024 caratteri.
* `metadata` (opzionale): versione, autore, licenza e altre meta-informazioni.
### Installare Skills personalizzate [#installare-skills-personalizzate]
**Metodo 1: importazione tramite impostazioni**
1. Apri **Settings → Skills**
2. Fai clic su **Import Skill**
3. Seleziona la cartella della Skill (o un archivio `.zip` / `.skill`)
4. Verdent convalida `SKILL.md` e la installa in `~/.verdent/skills/`
**Metodo 2: copia manuale**
```bash
cp -r my-custom-skill ~/.verdent/skills/
```
La Skill diventa disponibile dopo aver riavviato Verdent o aggiornato l'elenco delle Skills.
**Metodo 3: Skill a livello di progetto**
Posiziona la Skill all'interno della cartella del progetto:
```bash
cp -r my-custom-skill /path/to/your/project/.verdent/skills/
```
Le Skills a livello di progetto sono visibili solo all'interno di quel progetto e hanno priorità sulle Skills globali con lo stesso nome.
***
## Ambiti delle Skills [#ambiti-delle-skills]
Verdent supporta tre livelli di ambito per le Skills:
| Livello | Posizione | Visibilità |
| ------------ | ---------------------------- | -------------------------------------- |
| **Globale** | `~/.verdent/skills/` | Tutti i progetti e i workspace |
| **Progetto** | `/.verdent/skills/` | Solo i workspace del progetto corrente |
**Regole di priorità:**
Quando esistono Skills con lo stesso nome in più ambiti:
* Il progetto ha la precedenza sul globale
***
## Skill Store [#skill-store]
Verdent offre uno **Skill Store** per sfogliare e installare Skills della community e ufficiali.
### Sfogliare lo Skill Store [#sfogliare-lo-skill-store]
1. Apri **Settings → Skills**
2. Passa alla scheda **Store**
3. Sfoglia le Skills disponibili o usa la casella di ricerca
### Installare dallo Store [#installare-dallo-store]
1. Trova la Skill desiderata nello Store
2. Fai clic su **Install**
3. La Skill viene scaricata e installata automaticamente in `~/.verdent/skills/`
**Verifica di sicurezza:**
Le Skills installate dallo Store sono sottoposte a verifica del checksum SHA256 per garantire l'integrità e la sicurezza dei file.
***
## Esempi pratici [#esempi-pratici]
### Esempio 1: creare una nuova Skill con `skill-creator` [#esempio-1-creare-una-nuova-skill-con-skill-creator]
```
@skill-creator help me create a Skill for guiding the team on writing Go unit tests
```
L'agente:
1. Legge il contenuto della Skill `skill-creator`
2. Ti guida nella compilazione del nome, della descrizione e del prompt principale della Skill
3. Genera un file `SKILL.md` standard
4. Suggerisce il percorso di installazione e i passaggi di verifica
### Esempio 2: analizzare dati con `spreadsheet` [#esempio-2-analizzare-dati-con-spreadsheet]
```
@spreadsheet read sales-2025.xlsx from the project root, analyze Q1 sales trends, and generate a chart
```
L'agente:
1. Carica la Skill `spreadsheet`
2. Usa `pandas` e `openpyxl` per leggere il file Excel
3. Analizza i dati e genera visualizzazioni
4. Salva i risultati o li mostra nella conversazione
### Esempio 3: correggere la CI con `gh-fix-ci` [#esempio-3-correggere-la-ci-con-gh-fix-ci]
```
@gh-fix-ci my PR #123 GitHub Actions tests are failing, help me debug
```
L'agente:
1. Usa la CLI di `gh` per recuperare i log della CI per la PR #123
2. Analizza il fallimento (ad es. errori nei casi di test, problemi di dipendenze)
3. Propone una correzione
4. Con la tua approvazione, modifica il codice e invia la correzione
***
## Domande frequenti [#domande-frequenti]
Quando una Skill viene invocata, l'agente legge il file `SKILL.md`, che rientra nell'uso di token e quindi consuma crediti. La Skill stessa, tuttavia, non effettua chiamate aggiuntive a API.
Sì. Installa la Skill in `~/.verdent/skills/` (ambito globale) e sarà disponibile in tutti i progetti.
In **Settings → Skills**, fai clic con il tasto destro sulla Skill e seleziona **Delete**. Le Skills integrate contrassegnate come `undeletable` non possono essere eliminate e vengono reinstallate al successivo avvio.
Sì. Verdent rileva automaticamente le Skills in `~/.cursor/skills`, `~/.claude/skills` e `~/.codex/skills` e ti propone di importarle. Fai clic su **Import from External Sources** in **Settings → Skills**.
* **Project Rule**: istruzioni sempre attive, iniettate automaticamente in ogni conversazione
* **Skill**: pacchetti di conoscenza su richiesta, iniettati solo quando vengono invocati
Usa le regole per gli standard di codifica universali; usa le Skills per flussi di lavoro di dominio specifici.
Le Skills installate dallo Skill Store vengono controllate automaticamente in background per gli aggiornamenti. Le Skills installate manualmente vanno reimportate (sovrascrivendo la versione precedente) per essere aggiornate.
***
## Uso avanzato [#uso-avanzato]
### Incorporare script nelle Skills [#incorporare-script-nelle-skills]
Aggiungi una cartella `scripts/` alla tua Skill e fai riferimento agli script in `SKILL.md`:
```markdown
## Data Processing Script
Run the following command to process data:
\`\`\`bash
python scripts/process_data.py --input data.csv --output results.json
\`\`\`
```
L'agente legge questa istruzione ed esegue lo script quando necessario.
### Riferimenti alla documentazione [#riferimenti-alla-documentazione]
Memorizza documentazione API, specifiche o codice di esempio in una cartella `references/` e collegali in `SKILL.md`:
```markdown
## Reference Documentation
See [references/api-spec.md](references/api-spec.md) for the detailed API specification.
```
L'agente può leggere questi file di riferimento in base alle istruzioni della Skill.
***
## Best practice [#best-practice]
**Mantieni le Skills focalizzate.** Ogni Skill dovrebbe puntare a un singolo dominio o flusso di lavoro. Evita di creare Skills "tuttofare"—dividile invece in Skills più piccole e specializzate.
**Usa nomi chiari.** I nomi delle Skills dovrebbero essere concisi e descrittivi, ad es. `api-doc-generator` anziché `my-skill-1`.
**Fornisci esempi e riferimenti.** Includi esempi concreti e link di riferimento in `SKILL.md` per aiutare l'agente a comprendere meglio l'output atteso.
**Mantieni i numeri di versione.** Usa il campo `metadata.version` per tenere traccia di aggiornamenti e compatibilità.
**Testa prima di condividere.** Convalida la tua Skill in un progetto di test prima di distribuirla al team o pubblicarla nello Skill Store.
***
## Vedi anche [#vedi-anche]
Come funzionano i sottoagenti e come gestirli
Collega strumenti e servizi esterni tramite MCP
Configura Project Rule e User Rule sempre attive
Rivedi le modifiche al codice con il Reviewer integrato