Template di Claude Code: skill, agent, hook e altro ancora

Cosa sono i template di Claude Code?

I template di Claude Code sono file di configurazione riutilizzabili che personalizzano il comportamento di Claude Code in un progetto o in tutto l’ambiente locale. 

La cosa importante da capire è che i template sono basati su file. Non li installi tramite una classica GUI delle impostazioni per poi cliccare tra le schermate di configurazione. Invece, Claude Code individua file e cartelle specifici, carica i metadati rilevanti nel contesto e usa queste informazioni per decidere come comportarsi.

In pratica, sono di solito file in Markdown, JSON o shell archiviati in cartelle a livello di progetto come .claude/, oppure impacchettati in directory in stile plugin per la condivisione.

Una tipica struttura a livello di progetto può essere così:

my-app/
├── CLAUDE.md
├── .mcp.json
└── .claude/
    ├── skills/
    │   └── database-migration/
    │       └── SKILL.md
    ├── agents/
    │   └── security-auditor.md
    ├── commands/
    │   └── summarize-pr.md
    └── settings.json

Template di Claude Code vs CLAUDE.md

CLAUDE.md resta importante, ma ricopre un ruolo diverso. Consideralo come il briefing del progetto: cos’è il progetto, quali comandi contano, quali standard di coding si applicano e quali convenzioni architetturali Claude dovrebbe ricordare. 

Per una guida approfondita, vedi il nostro manuale su come scrivere CLAUDE.md.

I template sono più modulari:

• Una skill può codificare un workflow di migrazione. 
• Un agent può isolare una persona dedicata alla revisione della sicurezza. 
• Un hook può essere eseguito dopo le modifiche ai file. 
• Una configurazione MCP può collegare Claude a GitHub, SQLite o un altro sistema esterno.

Qui è anche dove i template si collegano a un design di workflow più ampio per Claude Code. I template ben fatti rendono al meglio se abbinati a buone abitudini di pianificazione, test e passaggio di contesto. 

Trovi altre pratiche del genere nel nostro manuale delle best practice.

I comandi personalizzati rientrano anche nel sistema delle skill, sebbene il formato legacy .claude/commands/ funzioni ancora. Il nuovo formato consigliato è .claude/skills/<name>/SKILL.md, che supporta l’invocazione con slash command e l’invocazione automatica da parte di Claude.

Che tipi di template di Claude Code posso usare?

L’ecosistema dei template di Claude Code è in genere organizzato in sei categorie: skill, agent, comandi, hook, integrazioni MCP e plugin. 

Le prime cinque modificano direttamente il comportamento di Claude. I plugin sono leggermente diversi: sono un formato di distribuzione che può raggruppare skill, agent, hook, comandi, server MCP e altri componenti in un pacchetto riutilizzabile.

Vedremo ciascuna di queste categorie qui sotto.

1. Skill

Le skill sono pacchetti di istruzioni per attività ripetibili e multi-step. Una skill è di solito una cartella che contiene un file SKILL.md con frontmatter YAML e un corpo in Markdown. 

Il frontmatter descrive cosa fa la skill e come dovrebbe comportarsi; il corpo indica a Claude quali passi seguire. Per un approfondimento dedicato, vedi questa guida sulle Claude Skills.

Claude usa la descrizione della skill per decidere quando è rilevante. Per impostazione predefinita, sia l’utente sia Claude possono invocare una skill: puoi digitare /skill-name, oppure Claude può caricarla automaticamente quando il task corrente corrisponde alla descrizione. Puoi anche disabilitare l’invocazione automatica del modello per workflow in cui vuoi il controllo manuale, come il deployment.

Ecco un breve esempio di file: .claude/skills/database-migration/SKILL.md

---
name: database-migration
description: Use when creating, reviewing, or modifying database migrations. Ensures migrations are reversible, tested, and checked before and after execution.
allowed-tools:
  - Read
  - Write
  - Bash
---

# Database Migration Skill

When working on a database migration:

1. Inspect the existing schema and migration history before writing changes.
2. Confirm whether the migration is additive, destructive, or data-transforming.
3. Create a reversible migration whenever the framework supports rollback.
4. Run the project’s migration check command before applying the migration.
5. Run tests that cover the affected models, queries, or API endpoints.
6. After writing the migration, summarize:
   - schema changes
   - rollback behavior
   - affected tables
   - test commands run

Questo è utile perché le istruzioni sono procedurali. Non stai solo dicendo a Claude di “fare attenzione con le migrazioni”: gli stai dando una checklist ripetibile. 

Le skill sono ideali per tutto ciò che altrimenti incolleresti in Claude più di due volte: generare endpoint API, scrivere changelog, impostare test, creare note di rilascio, rivedere pull request o eseguire controlli di migrazione.

Per un’ispirazione più ampia su cosa gli sviluppatori stanno trasformando in workflow AI riutilizzabili, vedi la nostra lista di Agent Skills.

2. Agent

Gli agent, più precisamente i sotto-agent personalizzati in Claude Code, sono assistenti AI specializzati con una propria definizione in Markdown, frontmatter YAML, restrizioni sugli strumenti, scelta del modello e prompt di sistema. 

Possono risiedere in .claude/agents/ per lo scope del progetto o in ~/.claude/agents/ per lo scope personale. Gli agent si creano chiedendolo a Claude o modificando direttamente i file markdown nella cartella .claude/agents/.

C’è una differenza reale tra skill e agent. Una skill definisce come eseguire un compito. Un agent definisce chi dovrebbe essere Claude mentre lavora: ruolo, focus, permessi e limiti.

Vediamo questo esempio di agent:

---
name: security-auditor
description: Reviews code for security vulnerabilities and produces a findings report without modifying files.
tools: Read, Glob, Grep, Bash
model: sonnet
---

You are a security auditor.

Your task is to inspect the codebase for vulnerabilities, risky patterns, and missing safeguards.

Rules:
- Do not edit files.
- Do not suggest broad rewrites unless directly tied to a security issue.
- Focus on authentication, authorization, input validation, secrets, dependency risk, and unsafe shell or SQL usage.
- Produce a findings report with severity, affected files, evidence, and recommended next steps.

Questo agent è utile perché fornisce a Claude confini chiari. In una sessione generale, Claude potrebbe mettersi a correggere i problemi appena li trova. Un agent “security auditor” è istruito a ispezionare e riportare soltanto, evitando modifiche. 

Gli agent sono ideali per domini specializzati come audit di sicurezza, revisione della documentazione, revisione dell’architettura, data engineering o controlli di qualità del codice, dove isolamento del contesto e limiti di permesso sono importanti.

Gli agent sono utili anche in coppia con skill specializzate. Per esempio, un agent security auditor potrebbe richiamare una skill per il findings report, mentre un agent reviewer frontend potrebbe usare una skill per il testing dei componenti.

3. Comandi

I comandi sono scorciatoie invocate con slash come /generate-tests, /check-deps o /summarize-pr. Storicamente, i comandi personalizzati venivano archiviati come file Markdown sotto .claude/commands/, con il nome del file come nome del comando. 

Claude Code supporta ancora questo formato legacy, ma consiglio di usare le skill per nuovi workflow in stile comando, perché supportano la stessa invocazione /name e l’invocazione automatica quando opportuno.

I comandi sono ideali quando vuoi che il trigger sia esplicito. Una skill potrebbe attivarsi automaticamente quando Claude rileva un task corrispondente, ma un comando dovrebbe partire solo quando lo decidi tu. Questo li rende utili come checkpoint: “genera i test adesso”, “riassumi questa PR ora”, “controlla le dipendenze adesso” o “prepara ora un messaggio di commit”.

4. Hook

Gli hook sono regole di automazione che si attivano in risposta agli eventi del ciclo di vita di Claude Code. Sono comandi shell definiti dall’utente che vengono eseguiti in punti specifici del ciclo di vita di Claude Code, offrendo un controllo deterministico sul comportamento. 

La differenza tra hook e gli altri template visti finora è che non sono attivati da ciò che chiedi, ma da ciò che fa Claude.

In parole semplici, non devi sperare che Claude si ricordi di formattare un file dopo averlo modificato: un hook può farlo automaticamente.

Gli attuali nomi di eventi per gli hook includono eventi come PreToolUse, PostToolUse, Notification e Stop. 

Esempio: eseguire un formatter dopo che Claude modifica o scrive un file:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write"
          }
        ]
      }
    ]
  }
}

Example: block risky shell commands before Claude runs them:
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "python3 .claude/hooks/block-dangerous-bash.py"
          }
        ]
      }
    ]
  }
}

Gli hook sono ideali per regole che Claude non dovrebbe poter saltare: eseguire un linter, formattare i file modificati, bloccare modifiche a file protetti, verificare il codice generato o inviare notifiche quando Claude ha bisogno di input. 

Per un tutorial approfondito, leggi la nostra Guida agli hook di Claude Code.

5. Integrazioni MCP

Le integrazioni MCP collegano Claude Code a strumenti esterni, fonti dati e API tramite il Model Context Protocol. MCP funge da livello connettore tra sistemi di AI e strumenti esterni. In Claude Code, ciò significa che Claude può andare oltre i file locali e i comandi della shell. 

Permette a Claude di interagire con servizi esterni come GitHub, database, sistemi di documentazione, piattaforme cloud o API interne, a seconda dei server MCP che configuri. Per una spiegazione completa e un progetto demo, vedi il nostro tutorial sul Model Context Protocol.

Un server MCP può esporre tre macro tipologie di capacità:

• Tools: funzioni eseguibili che Claude può chiamare, ad esempio creare una issue su GitHub o eseguire una query su un database.
• Resources: fonti di contesto in sola lettura, come un file, una riga di database o un documento.
• Prompts: template di task riutilizzabili esposti dal server.

Un .mcp.json a livello di progetto può configurare più server affiancati:

{
  "mcpServers": {
    "github": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "sqlite": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sqlite",
        "./data/app.db"
      ]
    }
  }
}

Questo è importante perché Claude può ragionare solo sul contesto e sugli strumenti a cui ha accesso. Senza MCP, può ispezionare i file locali ma non il tuo issue tracker, il database, l’ambiente cloud o un’API interna. 

L’MCP è ideale quando Claude deve lavorare con lo stack reale anziché con uno snapshot statico del codice e quando ha bisogno di accedere a dati esterni.

6. Plugin

I plugin sono pacchetti confezionati. Possono includere skill, agent, hook, configurazioni MCP, comandi e altri componenti in un’unica struttura installabile. 

In Claude Code, un plugin include tipicamente un manifest .claude-plugin/plugin.json e cartelle di componenti come skills/, agents/, hooks/ e .mcp.json alla radice del plugin.

Esempio di struttura di un plugin:

frontend-workflow-plugin/
├── .claude-plugin/
│   └── plugin.json
├── skills/
│   └── component-test/
│       └── SKILL.md
├── agents/
│   └── frontend-reviewer.md
├── hooks/
│   └── hooks.json
└── .mcp.json

Esempio di plugin json:

{
  "name": "frontend-workflow",
  "displayName": "Frontend Workflow",
  "version": "1.0.0",
  "description": "Frontend development workflow with review agents, test skills, and formatting hooks",
  "author": {
    "name": "Your Team"
  }
}

I plugin non aggiungono un nuovo tipo di comportamento. Rendono portatili gli altri tipi. Usa i plugin quando vuoi condividere un setup completo in un team, riutilizzare lo stesso workflow su più progetti o installare un pacchetto mantenuto dalla community invece di creare ogni file manualmente.

Per crearne uno da zero, vedi la Guida passo-passo ai plugin di Claude Code di DataCamp.

Quale tipo di template dovrei scegliere?

È comprensibile: tutti questi tipi possono confondere. Possono tutti cambiare il comportamento di Claude. La differenza sta soprattutto in come vengono attivati e che tipo di controllo offrono.

Per chiarire, ecco un confronto tra di loro:

Una semplice regola decisionale aiuta:

• Se vuoi applicare automaticamente una regola ogni volta che Claude tocca il codice, usa un hook. 
• Se vuoi che Claude assuma una profonda competenza di dominio per un task specifico, usa un agent. 
• Se vuoi codificare un workflow che Claude dovrebbe ripetere in modo coerente, usa una skill. 
• Se vuoi invocare tu stesso un’azione al momento giusto, usa un comando o una skill simile a un comando. 
• Se a Claude servono servizi esterni o dati live, usa MCP. 
• Se vuoi installare o condividere un setup di workflow completo, usa un plugin.

Nei progetti reali, questi tipi si combinano di solito. Un plugin per la sicurezza potrebbe includere un agent security-auditor, una skill audit-findings, un comando di controllo delle dipendenze e un hook pre-commit. L’agent definisce il ruolo, la skill definisce la struttura del report, il comando ti dà un checkpoint esplicito e l’hook impone il paletto.

Per workflow in cui Claude dovrebbe seguire un piano formale prima dell’implementazione, lo spec-driven development è spesso più adatto rispetto ai prompt ad hoc.

Dove posso trovare template di Claude Code?

Ci sono tre fonti pratiche: Anthropic, raccolte della community e te stesso.

Per prima cosa, parti dalle risorse ufficiali di Anthropic e dalla documentazione. La documentazione di Claude Code di Anthropic copre skill, sotto-agent, hook, MCP e plugin, ed è il posto migliore per verificare formati di file e comportamenti attuali prima di pubblicare qualcosa di produzione.

In secondo luogo, usa le raccolte della community. L’hub comunitario più visibile è aitmpl.com, che si definisce un catalogo di configurazioni pronte all’uso per progetti Claude Code. La navigazione attuale include Skill, Agent, Comandi, Impostazioni, Hook, MCP e Plugin. 

Il comando di installazione interattiva attuale è:

npx claude-code-templates@latest

La documentazione del progetto mostra anche un alias più corto:

npx cct@latest

Per componenti specifici, il README live su GitHub mostra comandi di installazione come:

npx claude-code-templates@latest --agent development-tools/code-reviewer --yes
npx claude-code-templates@latest --command performance/optimize-bundle --yes
npx claude-code-templates@latest --hook git/pre-commit-validation --yes
npx claude-code-templates@latest --mcp database/postgresql-integration --yes

Mostra anche l’installazione in batch di uno stack completo usando più flag in un unico comando.

Quando valuti i template della community, verifica alcuni segnali di qualità:

• La description è abbastanza specifica da far attivare correttamente la skill o l’agent a Claude?

• Gli allowed-tools sono limitati in modo mirato, o il template chiede inutilmente ampi permessi di scrittura e bash?

• Il repository è stato mantenuto di recente?

• Il template spiega cosa cambia?

• Include hook o server MCP che eseguono codice che non hai revisionato?

In terzo luogo, scrivi i tuoi. Di solito è la scelta giusta per workflow strettamente legati al tuo stack. Un template della community può darti una base utile, ma non può conoscere la tua policy interna sulle migrazioni, le convenzioni di naming, il modello dati o la tolleranza al rischio in fase di deployment.

Considerazioni finali

I template di Claude Code sono ciò che permette a Claude Code di passare da assistente sessione per sessione a un ambiente di sviluppo persistente. 

Le sei categorie che ho menzionato sono in realtà livelli: le skill codificano i workflow, gli agent definiscono i ruoli, i comandi creano azioni esplicite, gli hook impongono i paletti, MCP collega i sistemi esterni e i plugin impacchettano tutto per il riutilizzo.

Il posto migliore da cui partire non è un enorme stack di plugin. Io inizierei con una skill per il tuo workflow più ripetuto. Quando vedrai dove il comportamento predefinito di Claude crea ancora attrito, aggiungi un agent per la revisione specializzata, un hook per l’applicazione delle regole o un server MCP per l’accesso live ai sistemi.

Per approfondire Claude Code, dai un’occhiata ai nostri corsi Claude Code 101 e Claude Code in Action.