Claude Code Hooks: una guida pratica all’automazione del workflow

Quando lavori con Claude Code, noterai un problema ricorrente: scrive buon codice ma dimentica passaggi importanti come la formattazione, l’esecuzione dei test o il rispetto dei protocolli di sicurezza. Finisci per ripetere gli stessi promemoria all’infinito. Gli hook di Claude Code ti permettono di automatizzare questi promemoria eseguendo comandi shell automaticamente in punti specifici del tuo workflow.

In questo tutorial, ti mostro come impostare hook per la formattazione del codice, l’esecuzione dei test, le notifiche e la protezione dei file. Costruirai un sistema di automazione che fa rispettare i tuoi standard di sviluppo senza interventi manuali.

Per saperne di più su Claude Code, dai un’occhiata alla nostra guida sulle best practice di Claude Code e al tutorial sulle Claude Skills. Se vuoi imparare a configurare istruzioni a livello di progetto, consulta la nostra guida su come scrivere un CLAUDE.md.

TL;DR

• Gli hook di Claude Code sono comandi shell che vengono eseguiti automaticamente in punti specifici del ciclo di vita di Claude Code (prima/dopo le chiamate agli strumenti, all’avvio della sessione, quando Claude si ferma)

• Configuali in .claude/settings.json (progetto) o ~/.claude/settings.json (globale) usando JSON con eventi, matcher e comandi

• Usa gli hook PreToolUse per bloccare operazioni pericolose prima che avvengano (codice di uscita 2 = blocco)

• Usa gli hook PostToolUse per attività di pulizia come formattazione, linting o esecuzione dei test dopo che Claude ha scritto codice

• Gli hook ricevono contesto JSON su stdin e comunicano i risultati tramite codici di uscita, stdout e stderr

Cosa sono gli hook di Claude Code?

Gli hook di Claude Code sono comandi shell che vengono eseguiti automaticamente quando si verificano eventi specifici durante la tua sessione di coding con l’IA. Pensali come trigger automatizzati che eseguono i tuoi script personalizzati in momenti precisi—prima che Claude scriva un file, dopo che esegue un comando o quando ti invia una notifica.

Il sistema funziona monitorando le azioni di Claude Code e confrontandole con regole che definisci in un file di configurazione. Quando avviene una corrispondenza, il comando specificato viene eseguito con accesso al contesto di ciò che è appena successo. Questo ti dà controllo sul comportamento di Claude e ti permette di automatizzare attività ripetitive che altrimenti richiederebbero interventi manuali.

Ecco un hook di base che esegue un formatter ogni volta che Claude scrive un file Python:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "python -m black ."
          }
        ]
      }
    ]
  }
}

Questo hook ha tre parti: 

• L’evento: PostToolUse (dopo che Claude termina un’azione)

• Il matcher: Write (solo quando scrive file)

• Il comando: python -m black . (formatta i file Python nella directory corrente)

L’hook riceve informazioni dettagliate su ciò che Claude ha appena fatto tramite dati JSON inviati all’input dello script, così puoi creare automazioni più sofisticate che rispondono a modifiche specifiche dei file.

Se vuoi spingerti oltre con l’automazione di Claude Code, il nostro tutorial sulle Claude Code Routines mostra come pianificare hook e agent che si eseguono periodicamente nel cloud.

Vediamo come creare hook da zero e registrarli in Claude Code.

Prerequisiti

Prima di iniziare ti serviranno alcune cose:

• Claude Code installato e in esecuzione: Dovresti trovarti a tuo agio nell’usare Claude Code per attività di coding di base

• Familiarità con la riga di comando: Gli hook eseguono comandi shell, quindi ti servirà sapere come scrivere comandi terminale di base per il tuo sistema operativo

• Accesso a un editor di testo: Modificherai file di configurazione JSON per impostare i tuoi hook

• Directory di progetto: Un progetto di coding dove puoi testare gli hook in sicurezza senza intaccare lavori importanti

Non devi essere un esperto di scripting shell, ma capire come eseguire comandi come ls, cd e le operazioni base sui file ti aiuterà a seguire gli esempi. Se sei nuovo a bash o al terminale, ti consiglio il corso Introduction to Shell.

Primi passi con gli hook di Claude Code

Ora che sai cosa sono gli hook, configuriamo la tua prima automazione. Il processo prevede la scelta dell’evento giusto per le tue esigenze, la configurazione di una regola semplice e il test con un comando di base.

Capire gli eventi degli hook

Claude Code espone oltre 25 eventi per gli hook. La tabella qui sotto copre i 10 che userai più spesso. Per l’elenco completo, vedi la documentazione ufficiale degli hook.

PreToolUse e PostToolUse sono gli eventi più comuni. PreToolUse viene eseguito prima che Claude compia un’azione come scrivere un file o eseguire un comando, il che lo rende perfetto per la validazione o per bloccare operazioni pericolose. PostToolUse viene eseguito dopo che Claude completa un’azione ed è ideale per attività di pulizia come formattare il codice o eseguire i test.

UserPromptSubmit si attiva quando invii un prompt a Claude, prima che elabori la richiesta. Puoi usarlo per aggiungere contesto alla conversazione o per validare che i prompt rispettino determinati requisiti.

Notification viene eseguito quando Claude ti invia avvisi, ad esempio quando chiede il permesso di eseguire un comando o ha bisogno di un tuo input. PermissionRequest si attiva quando Claude Code mostra una finestra di dialogo per le autorizzazioni, permettendoti di approvare o negare automaticamente la richiesta per conto dell’utente.

Stop e SubagentStop si attivano quando Claude termina la risposta, utile per controlli finali o per generare report. La differenza è che Stop scatta quando Claude finisce la risposta complessiva, mentre SubagentStop lo fa quando un assistente generato da uno strumento (un “subagent”) termina il suo lavoro.

Gli eventi rimanenti, PreCompact, SessionStart e SessionEnd, gestiscono situazioni specifiche del ciclo di vita. PreCompact viene eseguito appena prima che Claude accorci la cronologia della conversazione. “SessionStart” scatta all’inizio di una nuova sessione per impostare i default, e SessionEnd si attiva alla chiusura della sessione, consentendo attività di pulizia o report finali.eporting.

Capire i matcher

I matcher sono i filtri che decidono quali azioni di Claude Code attivano un hook. Tecnicamente, sono stringhe interpretate come espressioni regolari, quindi puoi usare corrispondenze esatte o pattern più flessibili. 

I matcher più rilevanti sono quelli semplici come Write (si attiva quando Claude scrive un file) o Edit (si attiva quando modifica contenuti), e combinazioni come Edit|Write per coprire più azioni. 

Puoi anche usare prefissi come Notebook.* per abbinare tutti gli strumenti che iniziano con “Notebook”. Se vuoi che l’hook si attivi su ogni azione, usa la regex universale .*, una stringa vuota ("") o lascia matcher vuoto.

Poiché i matcher fanno distinzione tra maiuscole e minuscole e agiscono solo sui nomi delle azioni, è meglio mantenerli il più specifici possibile. Quando ti serve un controllo più fine (ad esempio, limitare l’hook a determinati tipi di file) puoi leggere il payload JSON che Claude passa all’hook e applicare lì le tue regex o condizioni.

Creare il tuo primo hook in Claude Code

Claude Code offre due modi per impostare gli hook: tramite il comando interattivo /hooks o modificando direttamente i file di configurazione. Iniziamo con l’approccio interattivo perché è più adatto ai principianti.

Usare il comando /hooks:

1. Apri Claude Code e digita /hooks nell’interfaccia della chat

2. Scegli l’evento di trigger (seleziona PostToolUse per questo esempio)

3. Seleziona "Add new hook" dal menu

4. Imposta il pattern del matcher (inserisci Write per puntare alla scrittura dei file)

5. Inserisci il tuo comando:

• Mac: say "Task complete"

• Windows: powershell -c [console]::beep()

• Linux: spd-say "Task complete"

6. Salva la configurazione e torna a Claude Code premendo Esc tre volte

Il comando /hooks aggiornerà automaticamente il tuo file delle impostazioni e ricaricherà la configurazione. Puoi anche usare /hooks in qualsiasi momento per visualizzare gli hook esistenti o apportare modifiche.

Se preferisci modificare direttamente i file di configurazione, gli hook si trovano in ~/.claude/settings.json per le impostazioni globali, in .claude/settings.json all’interno della directory del progetto (fai commit nel repo per condividere gli hook col team), o in .claude/settings.local.json per gli hook personali, che sono ignorati da git per impostazione predefinita. Per il nostro esempio sopra, apparirebbe così:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "say 'Task complete'"
          }
        ]
      }
    ]
  }
}

Dopo aver modificato manualmente il file, riavvia Claude Code o usa il comando /hooks per ricaricare la configurazione. Ora, ogni volta che Claude scrive un file, sentirai una notifica audio.

Testare il tuo hook

Prima di procedere, verifica che il tuo hook funzioni davvero:

1. Chiedi a Claude di scrivere un qualsiasi file Python (es., "Crea un file hello.py che stampa hello world")

2. Dovresti sentire la notifica audio quando Claude completa l’operazione di scrittura

3. Se non senti nulla, controlla il transcript di Claude Code premendo Ctrl-O per vedere eventuali messaggi di errore

4. I problemi comuni includono comando dell’hook non trovato, permessi file errati o errori di sintassi nel file di configurazione

Far funzionare questo test di base ti fa risparmiare tempo di debug in seguito, quando costruirai hook più complessi. Se hai appena modificato il file delle impostazioni manualmente, cambiato matcher o evento, o installato nuovi strumenti da usare in un comando di hook, può essere utile riaprire /hooks o riavviare Claude per ricaricare la configurazione.

Questo schema di base (evento, matcher, comando) è il fondamento di tutta l’automazione con gli hook. Puoi ampliarlo aggiungendo più comandi da eseguire contemporaneamente quando si attiva lo stesso evento. Ad esempio, potresti voler sia riprodurre un suono sia creare un backup quando Claude scrive un file. 

Puoi anche creare matcher separati per strumenti diversi all’interno dello stesso evento, così la scrittura dei file attiva azioni diverse rispetto alla modifica del codice. Tutti gli hook che corrispondono allo stesso pattern di strumento vengono eseguiti in parallelo. Se configuri più matcher per lo stesso evento, ogni hook viene eseguito quando si attiva il suo matcher.

Lavorare con gli input degli hook

Quando Claude Code attiva un hook, invia informazioni su ciò che è appena accaduto tramite lo standard input (stdin), un flusso di dati che arriva direttamente al tuo comando quando viene eseguito. Questi dati sono ciò che rende potenti gli hook, invece di semplici script lanciati a caso. 

Claude Code impacchetta queste informazioni in JSON e le fornisce a qualunque comando tu abbia configurato, che sia un semplice comando da terminale o uno script personalizzato.

Anatomia degli input degli hook

Ogni hook riceve un oggetto JSON con campi di base sulla sessione corrente:

{
  "session_id": "abc123",
  "transcript_path": "/Users/you/.claude/projects/my-project/conversation.jsonl", 
  "cwd": "/Users/you/my-project",
  "hook_event_name": "PostToolUse"
}

Vediamo ogni componente:

• session_id: identifica la conversazione corrente

• transcript_path: indica il percorso della cronologia della conversazione

• cwd: mostra la directory di lavoro

• hook_event_name: indica quale evento si è attivato

Avere questo contesto permette ai tuoi hook di prendere decisioni intelligenti: puoi tracciare quale conversazione ha attivato un’azione, accedere all’intera cronologia della chat se necessario o eseguire comandi nella directory corretta.

Variazioni degli input in base all’evento

Gli eventi degli strumenti come PreToolUse e PostToolUse includono dettagli extra sull’azione, ed è qui che gli hook diventano davvero utili per l’automazione. In PreToolUse, viene specificato il tool_input, e in PostToolUse anche il tool_response:

{
  "session_id": "abc123",
  "hook_event_name": "PostToolUse",
  "tool_name": "Write",
  "tool_input": {
    "file_path": "/path/to/file.py",
    "content": "print('Hello world')"
  },
  "tool_response": {
    "filePath": "/path/to/file.py", 
    "success": true
  }
}

Nell’input dell’hook, file_path mostra il percorso del file che viene scritto o modificato, mentre content contiene il testo esatto che lo strumento sta per scrivere. Dopo l’esecuzione, la risposta dello strumento ripete il filePath finale (nota il camelCase) per confermare quale file è stato effettivamente toccato, insieme a un flag success che indica se l’operazione è andata a buon fine. 

Queste informazioni dettagliate consentono ai tuoi hook di rispondere in modo diverso in base a ciò che è effettivamente successo. Potresti formattare solo i file Python, fare il backup solo di directory importanti o inviare notifiche solo quando vengono modificati determinati tipi di file.

Eventi come UserPromptSubmit sono più semplici perché non coinvolgono strumenti:

{
  "session_id": "abc123",
  "hook_event_name": "UserPromptSubmit", 
  "prompt": "Write a function to calculate factorial"
}

Nota che gli hook UserPromptSubmit non usano matcher nella loro configurazione. Si attivano su tutti i prompt, non sulle operazioni degli strumenti. Questo li rende perfetti per registrare le conversazioni, aggiungere automaticamente contesto al progetto o validare i prompt prima che Claude li elabori.

Leggere gli input degli hook nella pratica

Creiamo un hook che registra ogni prompt utente. Risolve il problema di perdere traccia di ciò che hai chiesto a Claude, soprattutto durante lunghe sessioni di coding. Prima, la configurazione dell’hook:

{
  "hooks": {
    "UserPromptSubmit": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/log_prompts.py"
          }
        ]
      }
    ]
  }
}

Poi, crea lo script Python in ~/.claude/log_prompts.py con il seguente contenuto:

#!/usr/bin/env python3
import json
import sys
from datetime import datetime

# Read JSON data from stdin
input_data = json.load(sys.stdin)

# Extract information
session_id = input_data.get("session_id", "unknown")
prompt = input_data.get("prompt", "")
timestamp = datetime.now().isoformat()

# Log the prompt
log_entry = f"{timestamp} | Session: {session_id[:8]} | {prompt}\n"
with open("prompt_history.txt", "a") as f:
    f.write(log_entry)

Lo script legge i dati JSON inviati da Claude Code e registra il prompt con il contesto della sessione. Crea così una cronologia ricercabile delle tue interazioni, che diventa preziosa quando devi ricordare come hai risolto un problema settimane dopo.

Lavorare con gli output degli hook

Dopo che il comando del tuo hook è stato eseguito, deve dire a Claude Code cosa è successo e se continuare normalmente. Questo meccanismo di controllo trasforma gli hook da semplici strumenti di logging in potenti automazioni di workflow che possono guidare il comportamento di Claude. Ciò avviene tramite tre canali: standard output (stdout), standard error (stderr) e codici di uscita.

Canali di output e codici di uscita

Lo standard output (stdout) rappresenta l’output normale. Ad esempio, se stampi qualcosa, va su stdout. Per la maggior parte degli hook, è ciò che appare nel transcript di Claude Code quando premi Ctrl-O, dandoti una traccia di ciò che ha fatto la tua automazione senza appesantire la conversazione principale.

Lo standard error (stderr) riguarda i messaggi di errore. Puoi scrivere su stderr usando 

• Python: print("message", file=sys.stderr) oppure

• Riga di comando: echo "message" >&2

La differenza chiave è che stderr può essere inviato direttamente a Claude per l’elaborazione automatica, permettendogli di rispondere ai problemi rilevati dai tuoi hook.

I codici di uscita dicono a Claude Code cosa fare dopo:

• Codice di uscita 0: Successo (mostra stdout all’utente)

• Codice di uscita 2: Errore bloccante (invia stderr a Claude)

• Altri codici: Errore non bloccante (mostra stderr all’utente, ma continua)

Questo sistema ti dà un controllo granulare su quando Claude deve fermarsi, continuare o ricevere feedback su ciò che ha scoperto la tua automazione. Vediamo esempi per i due codici di uscita più importanti.

Codice di uscita 0: Operatività normale

La maggior parte degli hook usa il codice di uscita 0 per indicare che è andato tutto bene. Ecco un hook completo che registra le operazioni sui file e notifica l’utente:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "python3 -c \"import datetime; open('activity.log','a').write('File written: ' + datetime.datetime.now().isoformat() + '\\n'); print('Logged file operation')\""
          }
        ]
      }
    ]
  }
}

Questo hook esegue due comandi: registra su un file e poi stampa un messaggio nel transcript. Ci sono molti modi per farlo, ma questo approccio è multipiattaforma ed evita di dipendere da specificità della riga di comando.

Poiché non c’è un codice di uscita esplicito, quello predefinito è 0. Il messaggio stampato appare nel transcript di Claude Code, dandoti feedback sul fatto che il logging abbia funzionato. Questo pattern è perfetto per costruire audit trail o tracciare nel tempo le modifiche che Claude apporta al tuo progetto.

Codice di uscita 2: Blocco con feedback

Il codice di uscita 2 invia direttamente a Claude il tuo messaggio di errore, permettendogli di rispondere automaticamente. Qui gli hook diventano un meccanismo di sicurezza, non solo automazione. Ecco un hook che blocca operazioni pericolose sui file:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/security_check.py"
          }
        ]
      }
    ]
  }
}

Dovrai creare lo script di controllo sicurezza in ~/.claude/security_check.py:

#!/usr/bin/env python3
import json
import sys

# Read hook input
input_data = json.load(sys.stdin)
tool_input = input_data.get("tool_input", {})
file_path = tool_input.get("file_path", "")

# Check for dangerous patterns
dangerous_paths = ["/etc/", "/usr/", "production.conf"]
is_dangerous = any(pattern in file_path for pattern in dangerous_paths)

if is_dangerous:
    # Block the operation and tell Claude why
    print(f"Blocked modification of {file_path} - this appears to be a system or production file", file=sys.stderr)
    sys.exit(2)  # Sends stderr message to Claude
else:
    # Allow the operation
    print(f"Approved modification of {file_path}")
    sys.exit(0)  # Shows stdout in transcript

Quando questo hook rileva un percorso pericoloso, esce con codice 2. Claude Code invia il messaggio su stderr a Claude, che può quindi spiegarti perché l’operazione è stata bloccata e suggerire alternative. Questo previene danni accidentali ai file di sistema mantenendo Claude informato sulle tue policy di sicurezza.

Costruire un hook di notifica intelligente per Claude Code

Costruiamo un hook di notifica migliorato che combina l’elaborazione dell’input con una gestione intelligente dell’output. Risolve il problema del rumore del nostro hook originale che avvisava a ogni modifica di file:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/smart_notify.py"
          }
        ]
      }
    ]
  }
}

Crea lo script di notifica in ~/.claude/smart_notify.py:

#!/usr/bin/env python3
import json
import sys
import os
import subprocess

# Read the hook input
input_data = json.load(sys.stdin)
tool_input = input_data.get("tool_input", {})
file_path = tool_input.get("file_path", "")

# Categorize file importance
important_extensions = [".py", ".js", ".ts", ".java", ".cpp"]
config_files = ["Dockerfile", "requirements.txt", "package.json"]

is_code = any(file_path.endswith(ext) for ext in important_extensions)
is_config = any(filename in file_path for filename in config_files)

if is_code:
    # Important: notify and log
    print(f"Code file modified: {os.path.basename(file_path)}")
    subprocess.run(["say", "Code updated"], check=False)  # Mac
    sys.exit(0)  # Show message in transcript
elif is_config:
    # Very important: louder notification
    print(f"Configuration file changed: {os.path.basename(file_path)}")
    subprocess.run(["say", "Configuration updated - review changes"], check=False)
    sys.exit(0)
else:
    # Not important: silent success
    sys.exit(0)

Questo hook legge l’input per capire quale file è stato modificato, decide l’importanza della notifica in base al tipo di file, usa stdout per registrare le modifiche importanti nel transcript, attiva avvisi audio diversi a seconda del tipo di file ed esce sempre con codice 0 poiché si tratta di azioni informative, non bloccanti.

La combinazione di analisi dell’input e controllo dell’output crea un hook che si comporta in modo intelligente in base al contesto, fornendo il giusto livello di feedback sia a te sia a Claude Code. Invece di ricevere notifiche fastidiose per ogni file temporaneo, sentirai solo quelle che contano davvero per il tuo progetto.

Nota che questo esempio usa il comando say, disponibile su macOS. Su Linux potresti usare notify-send e su Windows un comando PowerShell per ottenere notifiche simili.

Trappole comuni con gli hook di Claude Code

Alcune cose che mettono in difficoltà la maggior parte delle persone nella prima settimana con gli hook:

Le istruzioni echo nel profilo della shell rompono gli hook. Gli hook girano in shell non interattive che caricano il tuo ~/.zshrc o ~/.bashrc. Se il tuo profilo ha istruzioni echo incondizionate, queste antepongono testo allo stdout dell’hook e interrompono il parsing JSON. Incapsulale in un controllo per shell interattiva:

if [[ $- == *i* ]]; then
  echo "Welcome back"
fi

Gli hook Stop possono andare in loop infinito. Un hook Stop che esce con codice 2 forza Claude a continuare a lavorare. Se il tuo script non controlla stop_hook_active dall’input JSON e non esce pulitamente quando è true, entrerai in loop fino al timeout. Includi sempre un controllo di uscita anticipata.

I matcher fanno distinzione tra maiuscole e minuscole. bash non corrisponde a Bash. Usa il nome esatto dello strumento così come appare in Claude Code.

L’output è limitato a 10.000 caratteri. Se il tuo hook ne genera di più, verrà troncato prima di essere inserito nel contesto di Claude. Mantieni stdout conciso e fai emergere solo ciò che serve al modello per agire.

Confusione tra hook a livello di team e personali. Gli hook in .claude/settings.json sono condivisi con il team (fai commit nel repo). Per gli hook personali che non vuoi condividere, usa .claude/settings.local.json, che è ignorato da git per impostazione predefinita.

Hook vs. skill: quando usare cosa

Gli hook e le Claude Skills hanno scopi diversi e funzionano al meglio insieme. Una skill è un file markdown che insegna a Claude come fare qualcosa (procedure, convenzioni, template). Un hook è un comando shell che fa rispettare una regola in modo deterministico, a prescindere da ciò che decide Claude.

La distinzione conta: una skill è un suggerimento che il modello può ignorare sotto pressione; un hook parte ogni volta. Scrivi una skill per documentare la procedura di migrazione del tuo team. Scrivi un hook PostToolUse per eseguire il linter di migrazione su ogni file .sql che Claude scrive. La skill rende Claude competente; l’hook rende Claude responsabile.

Pattern avanzati per gli hook di Claude Code

Oltre a notifiche e logging di base, gli hook possono risolvere problemi reali di workflow di sviluppo che i team affrontano ogni giorno. Ecco alcune idee che puoi adattare ai tuoi progetti.

La cosa bella è che non devi nemmeno costruire manualmente questi hook. Puoi semplicemente dare a Claude Code una delle idee di prompt qui sotto, insieme alla Hooks reference nella sua documentazione, e genererà il codice e il JSON di configurazione pertinenti.

Ognuno di questi pattern può essere personalizzato per i tuoi strumenti e il tuo workflow. Inizia da quelli che risolvono le tue frustrazioni quotidiane più grandi, poi amplia l’automazione man mano che prendi confidenza con lo sviluppo di hook.

Hook avanzati per sicurezza e compliance

Gli hook sono ottimi per far rispettare regole di sicurezza e standard di compliance. Ecco quattro casi d’uso.

Scanner di API key

• Problema: Commit accidentali di segreti nel controllo versione

• Trigger: Prima di scrivere qualsiasi file

• Soluzione: Scansione del contenuto dei file per API key, token e password usando pattern regex

“Crea uno script Python che legga il JSON di input dell’hook, estragga il contenuto del file e usi pattern regex per rilevare formati comuni di segreti come api_key=, token: o password=.  Per ogni corrispondenza sospetta, effettua una verifica locale e non inviare mai segreti grezzi all’esterno. 

Invia solo estratti mascherati (es., mantieni 4 caratteri di prefisso/suffisso) o hash all’API di Anthropic per analizzare stringhe sospette e determinare se sono segreti reali o nomi di variabili. Esci con codice 2 e fornisci a Claude feedback sui segreti rilevati e alternative più sicure.”

Enforcer dell’header di licenza

• Problema: Progetti open source con nuovi file senza gli header di licenza richiesti

• Trigger: Prima di scrivere file di sorgente

• Soluzione: Validare che i nuovi file .py, .js, .java contengano il testo della licenza corretto

“Analizza l’input dell’hook per ottenere il contenuto del file e verifica se le prime 10 righe contengono testo di licenza tramite confronto di stringhe. Per una validazione più sofisticata, invia l’header del file a Claude tramite l’API di Anthropic per verificare che contenga le corrette note di copyright e le informazioni di licenza. Blocca la creazione del file con codice 2 se mancano gli header, e fornisci a Claude il template di licenza corretto da aggiungere.”

Guardiano dei file di produzione

• Problema: Modifica accidentale di file di configurazione critici di sistema

• Trigger: Prima di modificare file in directory sensibili

• Soluzione: Bloccare modifiche a /etc/, nginx.conf, database.yml e altre config critiche

“Estrai il percorso del file dal JSON di input dell’hook e verifica se corrisponde a pattern come /etc/, production.yml o altri nomi di file critici. Usa l’API di Claude per analizzare il percorso del file e determinare se è un file di configurazione che potrebbe influenzare i sistemi di produzione. Esci con codice 2 e fornisci indicazioni specifiche su pratiche di sviluppo più sicure quando vengono rilevati percorsi pericolosi.”

Ottimizzatore di immagini

• Problema: File immagine di grandi dimensioni che rallentano applicazioni e repository

• Trigger: Dopo l’aggiunta di nuovi file immagine

• Soluzione: Compressione di file PNG/JPEG mantenendo la qualità visiva

“Analizza l’input dell’hook per ottenere il percorso del file e verifica se è un’immagine tramite l’estensione. Esegui strumenti di compressione come imageoptim o chiama l’API di TinyPNG per comprimere l’immagine preservando la qualità. Registra i risultati della compressione su stdout così puoi vedere il risparmio di dimensioni nel transcript di Claude.”

Hook avanzati per l’automazione del controllo versione

Workflow Git e documentazione sono aree in cui gli hook sono molto utili. Vediamo alcune idee.

Validatore di branch Git

• Problema: Membri del team che fanno push per errore su branch protetti

• Trigger: Prima di qualsiasi operazione di scrittura o modifica file

• Soluzione: Controllare il branch Git corrente e bloccare le operazioni su main/master/production

“Usa un semplice comando bash git branch --show-current per ottenere il nome del branch e confrontarlo con un elenco di branch protetti. Se sei su un branch protetto, esci con codice 2 e invia a Claude un messaggio di errore che spieghi le policy di protezione dei branch. Per regole di naming più complesse, usa l’API di Claude per analizzare i nomi dei branch e determinare se corrispondono a pattern di protezione.”

Auto-commit intelligente

• Problema: Dimenticare di fare commit o scrivere messaggi di commit scadenti

• Trigger: Dopo qualsiasi modifica ai file

• Soluzione: Staging e commit automatici con messaggi descrittivi generati dall’IA

“Leggi i percorsi dei file modificati dall’input dell’hook, esegui git diff per ottenere le differenze e invia il diff all’API di Claude con un prompt che chieda un messaggio di commit conciso. Usa il messaggio generato con i comandi git add e git commit per fare automaticamente il commit. Includi nomi dei file e tipi di modifiche nel prompt all’API per assicurare che i messaggi seguano gli standard dei conventional commit.”

Generatore di documentazione

• Problema: Documentazione API non allineata ai cambiamenti del codice

• Trigger: Dopo la modifica di file di interfaccia (controller, model, API)

• Soluzione: Esecuzione automatica di strumenti di documentazione come JSDoc, Sphinx o generatori OpenAPI

“Controlla il percorso del file modificato per determinare se è un endpoint API, un model o un file di interfaccia usando il pattern matching. Invia il contenuto del file all’API di Claude, chiedendo di estrarre le modifiche all’API e generare aggiornamenti della documentazione. Esegui lo strumento di documentazione appropriato (jsdoc, sphinx-build, ecc.) e fai automaticamente il commit della documentazione aggiornata.

Hook avanzati per collaborazione e integrazione del workflow

Infine, gli hook possono aiutare a tenere aggiornati tutti i membri del team.

Integrazione con Slack

• Problema: Il team non è a conoscenza di cambiamenti importanti nei codebase condivisi

• Trigger: Quando vengono inviate notifiche per operazioni significative

• Soluzione: Pubblicare messaggi formattati nei canali del team con nomi dei file e riepiloghi delle modifiche

“Estrai le informazioni sui file dall’input dell’hook e filtra per tipi importanti come codice sorgente o file di configurazione. Usa l’API di Claude per generare un riepilogo in linguaggio naturale di ciò che è cambiato basandoti su nomi e tipi di file. Invia il messaggio formattato a Slack usando webhook con menzioni dei membri del team per i cambiamenti critici.”

Dispatcher di webhook

• Problema: Trigger manuali delle pipeline CI/CD che causano ritardi nel deployment

• Trigger: Quando si verificano eventi specifici (cambi config, file di deployment modificati)

• Soluzione: Chiamare API esterne per attivare build, deployment o altri processi automatici

“Controlla il percorso del file modificato rispetto a pattern come Dockerfile, package.json o config di deployment per determinare se la CI/CD deve essere attivata. Usa la libreria requests in Python per chiamare webhook con header di autenticazione e payload con i dettagli delle modifiche. Includi percorsi dei file e metadati delle modifiche nel payload così i sistemi esterni possono decidere in modo intelligente cosa buildare o distribuire.”

Updater della status page

• Problema: I clienti non sono informati su attività di manutenzione o deployment

• Trigger: Quando vengono modificati file di deployment o infrastruttura

• Soluzione: Aggiornare le status page dei servizi con notifiche di manutenzione

“Analizza l’input dell’hook per rilevare cambi ai file di infrastruttura come manifest Kubernetes o config Terraform usando pattern sui percorsi. Genera messaggi di manutenzione con l’API di Claude in base al tipo di modifica infrastrutturale rilevata. Pubblica aggiornamenti di stato su servizi come StatusPage.io o PagerDuty usando le loro REST API con i tipi di incidente appropriati e la durata stimata.”

Notificatore di stato del team

• Problema: Conflitti quando più sviluppatori lavorano sugli stessi feature senza saperlo

• Trigger: All’avvio di una nuova sessione di Claude Code

• Soluzione: Avvisare i canali del team che stai iniziando a lavorare su un progetto o componente specifico

“Leggi la directory del progetto dall’input dell’hook e usa l’API di Claude per analizzare i file recenti o la cronologia git per capire su che tipo di lavoro ti stai concentrando. Invia un messaggio formattato ai canali di comunicazione del team con il tuo nome, il nome del progetto e l’area di focus. Includi durata stimata del lavoro e invita i membri del team a coordinarsi se stanno lavorando su feature correlate.”

Considerazioni finali

Gli hook di Claude Code trasformano gli assistenti di coding basati su IA, spesso imprevedibili, in workflow automatizzati che si attivano esattamente quando ne hai bisogno. In questo tutorial, hai imparato a impostare gli hook usando sia il comando interattivo /hooks sia la configurazione manuale, a comprendere i dati di input JSON che alimentano l’automazione intelligente e a controllare il comportamento di Claude tramite codici di uscita e output strutturati. 

I pattern pratici che abbiamo visto includono validator di sicurezza che bloccano operazioni pericolose e notifiche intelligenti che riducono il rumore. Questi esempi mostrano come gli hook risolvono problemi reali di sviluppo dandoti il pieno controllo sul tuo assistente IA. Ora che conosci le basi, puoi creare automazioni che si adattano alle esigenze specifiche del workflow del tuo team. 

Per approfondire l’uso degli strumenti di IA, dai un’occhiata al corso di DataCamp Understanding Prompt Engineering, che copre strategie di prompting direttamente utili nello sviluppo degli hook. Per competenze di coding con IA più ampie, prova il nostro Intermediate ChatGPT per sviluppare le abilità che rendono gli assistenti IA partner più affidabili nel tuo workflow di sviluppo.