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

Quando lavori con Claude Code, noterai un problema frequente: scrive buon codice ma si 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.

Questo tutorial ti mostra come configurare 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 in modo costante i tuoi standard di sviluppo senza interventi manuali.

Per saperne di più sul large language model (LLM) che alimenta Claude Code, dai un’occhiata a questo articolo su Claude Sonnet 4.5. Ti consiglio anche il nostro tutorial su Moltbot (Clawdbot) e il tutorial su Claude Cowork.

Cosa sono gli hook di Claude Code?

Gli hook di Claude Code sono comandi shell che vengono eseguiti automaticamente quando, durante la tua sessione di coding con l’IA, si verificano eventi specifici. Pensali come trigger automatici che lanciano 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 c’è una corrispondenza, il comando specificato viene eseguito con accesso al contesto di ciò che è appena accaduto. In questo modo controlli il comportamento di Claude e automatizzi attività ripetitive che altrimenti richiederebbero un intervento manuale.

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 costruire automazioni più sofisticate che reagiscono a modifiche specifiche dei file.

Se ti interessa l’automazione oltre i workflow di coding, Claude Cowork offre un’automazione assistita dall’IA simile per attività su file e documenti.

A breve vedremo come creare hook da zero e registrarli in Claude Code per integrarli nei tuoi workflow.

Prerequisiti

Prima di addentrarti negli hook di Claude Code, ti serviranno alcune cose:

• Claude Code installato e in esecuzione: Dovresti sentirti 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 dovrai 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 testare gli hook in sicurezza senza intaccare lavori importanti

Non serve essere esperti di shell scripting, ma capire come eseguire comandi come ls, cd e le operazioni base sui file ti aiuterà a seguire gli esempi. Se sei alle prime armi con bash o il terminale, ti consiglio il nostro corso Introduction to Shell.

Prime configurazioni con gli hook di Claude Code

Ora che sai cosa sono gli hook, configuriamo la tua prima automazione. Il processo prevede di scegliere l’evento giusto per le tue esigenze, impostare una regola semplice e testarla con un comando di base.

Capire gli eventi degli hook

Claude Code offre dieci eventi diversi in cui puoi eseguire i tuoi comandi. Ogni evento si attiva in un momento specifico, dandoti controllo su parti diverse del tuo workflow:

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, ed è perfetto per la validazione o per bloccare operazioni pericolose. PostToolUse si attiva dopo che Claude completa un’azione, ed è ideale per attività di cleanup 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 verificare che i prompt rispettino determinati requisiti.

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

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

Gli eventi rimanenti, PreCompact e SessionStart, gestiscono situazioni speciali come la pulizia della conversazione e l’inizializzazione della sessione.

Gli eventi residui, PreCompact, SessionStart e SessionEnd, gestiscono situazioni legate al ciclo di vita. PreCompact viene eseguito subito 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 operazioni di cleanup o report finali.

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 in bianco.

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 (per esempio limitare l’hook a certi 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 configurare gli hook: tramite il comando interattivo /hooks o modificando direttamente i file di configurazione. Iniziamo con l’approccio interattivo, più adatto ai principianti.

Usare il comando /hooks:

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

2. Scegli il tuo evento trigger (per questo esempio seleziona PostToolUse)

3. Seleziona "Add new hook" dal menu

4. Imposta il pattern del matcher (inserisci Write per mirare 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 file delle impostazioni e ricaricherà la configurazione. Puoi 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 o in .claude/settings.json all’interno della directory del tuo progetto. Per l’esempio sopra, sarebbe così:

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

Dopo aver modificato il file manualmente, 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 proseguire, verifica che il tuo hook funzioni davvero:

1. Chiedi a Claude di scrivere un file Python qualsiasi (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 quando costruirai hook più complessi. Se hai appena modificato manualmente il file delle impostazioni, 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 estenderlo aggiungendo più comandi da eseguire simultaneamente quando si attiva lo stesso evento. Per 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 di 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 il proprio matcher è attivato.

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 rendono gli hook potenti, non semplici script avviati a caso. 

Claude Code impacchetta queste informazioni in JSON e le passa 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 è stato 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 serve o eseguire comandi nella directory corretta.

Variazioni di input basate sull’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, è specificato il tool_input, e in PostToolUse inoltre 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 riporta il filePath finale (nota il camelCase) per confermare quale file è stato effettivamente toccato, insieme al flag success che indica se l’operazione è andata a buon fine. 

Queste informazioni dettagliate permettono ai tuoi hook di reagire in modo diverso in base a ciò che è successo. Puoi formattare solo i file Python, fare il backup solo di directory importanti o inviare notifiche solo quando vengono modificati certi 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 di progetto o validare i prompt prima che Claude li elabori.

Leggere l’input dell’hook nella pratica

Creiamo un hook che registra ogni prompt utente. Risolve il problema di perdere traccia di ciò che hai chiesto a Claude di fare, 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. In questo modo crei una cronologia ricercabile delle tue interazioni, utilissima quando, settimane dopo, devi ricordare come hai risolto un problema.

Lavorare con gli output degli hook

Dopo l’esecuzione del comando dell’hook, è necessario comunicare a Claude Code cosa è successo e se proseguire 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) è 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 un resoconto 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, consentendogli 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 lo stdout all’utente)

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

• Codice di uscita 3: Esecuzione differita (indica che il comando è terminato senza errori, ma i suoi effetti sono rinviati fino al soddisfacimento di condizioni aggiuntive) 

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

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

Codice di uscita 0: Operatività normale

La maggior parte degli hook usa il codice 0 per indicare che tutto è andato 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 azioni: registra su un file, poi stampa un messaggio nel transcript. Ci sono molti modi per farlo, ma questo approccio è multipiattaforma e non dipende da specificità della riga di comando.

Poiché non c’è un codice di uscita esplicito, si assume 0. Il messaggio stampato appare nel transcript di Claude Code, dandoti conferma che il logging ha funzionato. Questo pattern è perfetto per creare 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 il tuo messaggio di errore direttamente a Claude, permettendogli di rispondere automaticamente. Qui gli hook diventano un meccanismo di sicurezza, non solo di 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ò spiegarti perché l’operazione è stata bloccata e suggerire alternative. Ciò previene danni accidentali ai file di sistema mantenendo Claude informato sulle tue policy di sicurezza.

Creare un hook di notifica smart 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 e 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 i cambiamenti davvero rilevanti per il tuo progetto.

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

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 quotidianamente. Ecco alcune idee da adattare ai tuoi progetti.

La cosa bella è che non devi per forza costruire questi hook manualmente. Puoi semplicemente dare a Claude Code una delle idee di prompt qui sotto, insieme alla documentazione di riferimento degli hook, e genererà il codice e il JSON di configurazione rilevanti.

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

Hook avanzati per sicurezza e compliance

Scanner di chiavi API

• Problema: Commit accidentale di segreti nel controllo versione

• Trigger: Prima di scrivere qualunque file

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

“Crea uno script Python che legga l’input JSON 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 in chiaro all’esterno. 

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

Enforcer dell’header di licenza

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

• Trigger: Prima di scrivere file di sorgente

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

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

Protezione dei file di produzione

• Problema: Modifiche accidentali a file di configurazione critici di sistema

• Trigger: Prima di modificare file in directory sensibili

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

“Estrai il percorso del file dall’input JSON 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 stabilire se è un file di configurazione che potrebbe influire sui 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 pesanti 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 in base all’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ì potrai vedere il risparmio di spazio nel transcript di Claude.”

Hook avanzati per l’automazione del controllo versione

Validator del branch Git

• Problema: Membri del team che spingono accidentalmente modifiche su branch protetti

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

• Soluzione: Verificare 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 corrente e confrontarlo con un elenco di branch protetti. Se ti trovi 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 stabilire se corrispondono ai pattern di protezione.”

Auto-commit smart

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

• Trigger: Dopo qualunque modifica ai file

• Soluzione: Stage 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 modifiche e invia il diff all’API di Claude con un prompt che richieda un messaggio di commit conciso. Usa il messaggio generato con i comandi git add e git commit per effettuare automaticamente il commit. Includi nel prompt all’API i nomi dei file e i tipi di modifica per assicurarti che i messaggi seguano gli standard dei conventional commits.”

Generatore di documentazione

• Problema: Documentazione API non allineata con le modifiche al codice

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

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

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

Hook avanzati per collaborazione e integrazione del workflow

Integrazione con Slack

• Problema: Il team non è al corrente di modifiche importanti ai codebase condivisi

• Trigger: Quando vengono inviate notifiche per operazioni significative

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

“Estrai le informazioni sui file dall’input dell’hook e filtra per tipi di file importanti come sorgenti o configurazioni. Usa l’API di Claude per generare un riepilogo leggibile delle modifiche in base a nomi e tipi di file. Invia il messaggio formattato a Slack usando webhook con menzioni dei membri del team per le modifiche critiche.”

Dispatcher di webhook

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

• Trigger: Quando si verificano eventi specifici (modifiche alla configurazione, file di deployment modificati)

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

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

Aggiornamento 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 pagine di stato del servizio con notifiche di manutenzione

“Analizza l’input dell’hook per modifiche a file di infrastruttura come manifest Kubernetes o config Terraform usando pattern sui percorsi dei file. Genera messaggi di manutenzione con l’API di Claude in base al tipo di cambiamenti infrastrutturali rilevati. Pubblica aggiornamenti di stato su servizi come StatusPage.io o PagerDuty tramite le loro REST API con tipi di incidente appropriati e durata stimata.”

Notificatore dello 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 cosa si sta lavorando. Invia un messaggio formattato ai canali di comunicazione del team con il tuo nome, il nome del progetto e l’area di focus. Includi la durata stimata del lavoro e invita i membri del team a coordinarsi se stanno lavorando su feature correlate.”

Conclusione

Gli hook di Claude Code trasformano gli assistenti di coding IA, a volte imprevedibili, in workflow automatizzati che si attivano esattamente quando ne hai bisogno. In questo tutorial hai imparato a configurare gli hook sia con il comando interattivo /hooks sia con la configurazione manuale, a capire i dati 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 validatori di sicurezza che bloccano operazioni pericolose e notifiche smart 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 hai compreso le basi, puoi costruire automazioni su misura per il workflow del tuo team. 

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