Claude Code Hooks: een praktische gids voor workflow-automatisering

Als je werkt met Claude Code, valt een veelvoorkomend probleem op: het schrijft goede code, maar vergeet belangrijke stappen zoals formatteren, tests draaien of beveiligingsprotocollen volgen. Je eindigt ermee dat je dezelfde herinneringen steeds opnieuw geeft. 

Met Claude Code Hooks kun je deze reminders automatiseren door shellopdrachten automatisch uit te voeren op specifieke momenten in je workflow.

In deze tutorial leer je hooks in te stellen voor codeformattering, testuitvoering, meldingen en bestandsbescherming. Je bouwt een automatiseringssysteem dat je ontwikkelingsstandaarden consequent afdwingt zonder handmatige tussenkomst.

Wil je meer weten over het large language model (LLM) achter Claude Code? Lees dan dit artikel over Claude Sonnet 4.5. Ik raad ook onze Moltbot (Clawdbot)-tutorial en Claude Cowork-tutorial aan.

Wat zijn Claude Code Hooks?

Claude Code Hooks zijn shellopdrachten die automatisch worden uitgevoerd wanneer specifieke gebeurtenissen plaatsvinden tijdens je AI-codesessie. Zie ze als geautomatiseerde triggers die je eigen scripts op precieze momenten uitvoeren—vóórdat Claude een bestand schrijft, nadat het een opdracht draait of wanneer het je een melding stuurt.

Het systeem werkt door de acties van Claude Code te monitoren en ze te matchen met regels die jij definieert in een configuratiebestand. Wanneer er een match is, wordt je opgegeven opdracht uitgevoerd met toegang tot context over wat er net is gebeurd. Zo krijg je controle over het gedrag van Claude en kun je repetitieve taken automatiseren die anders handmatige tussenkomst vereisen.

Hier is een basis-hook die een codeformatter draait telkens wanneer Claude een Python-bestand schrijft:

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

Deze hook heeft drie onderdelen: 

• De gebeurtenis: PostToolUse (nadat Claude een actie voltooit)

• De matcher: Write (alleen bij het schrijven van bestanden)

• De opdracht: python -m black . (format Python-bestanden in de huidige map)

De hook ontvangt gedetailleerde informatie over wat Claude zojuist deed via JSON-data die naar de input van het script wordt gestuurd, zodat je geavanceerdere automatisering kunt bouwen die reageert op specifieke bestandswijzigingen.

Als je geïnteresseerd bent in automatisering buiten codeworkflows, biedt Claude Cowork vergelijkbare AI-ondersteunde automatisering voor bestanden en documenttaken.

Hierna bekijken we hoe je zulke hooks from scratch maakt en registreert in Claude Code om ze aan je workflows toe te voegen.

Vereisten

Voordat je met Claude Code Hooks aan de slag gaat, heb je het volgende nodig:

• Claude Code geïnstalleerd en draaiend: Je moet vertrouwd zijn met het gebruik van Claude Code voor basis-codetaken

• Bekend met de command line: Hooks draaien shellopdrachten, dus je moet basisterminalopdrachten voor jouw besturingssysteem kunnen schrijven

• Toegang tot een teksteditor: Je bewerkt JSON-configuratiebestanden om je hooks in te stellen

• Projectmap: Een codeproject waarin je hooks veilig kunt testen zonder belangrijk werk te beïnvloeden

Je hoeft geen expert in shell scripting te zijn, maar begrijpen hoe je opdrachten als ls, cd en basisbestandshandelingen uitvoert, helpt bij het volgen van de voorbeelden. Als je nieuw bent met bash-scripting of de terminal, raad ik onze Introduction to Shell-cursus aan.

Aan de slag met Claude Code Hooks

Nu je weet wat hooks zijn, gaan we je eerste automatisering instellen. Het proces bestaat uit het kiezen van de juiste gebeurtenis voor jouw behoefte, het configureren van een eenvoudige regel en het testen met een basisopdracht.

Hook-gebeurtenissen begrijpen

Claude Code biedt tien verschillende gebeurtenissen waarop je je opdrachten kunt draaien. Elke gebeurtenis triggert op een specifiek moment, zodat je verschillende delen van je workflow kunt aansturen:

PreToolUse en PostToolUse zijn de meest gebruikte gebeurtenissen. PreToolUse draait voordat Claude een actie uitvoert, zoals een bestand schrijven of een opdracht draaien; ideaal voor validatie of het blokkeren van gevaarlijke operaties. PostToolUse draait nadat Claude een actie heeft voltooid; handig voor opruimtaken zoals code formatteren of tests draaien.

UserPromptSubmit triggert wanneer je een prompt naar Claude verstuurt, vóórdat het je verzoek verwerkt. Je kunt dit gebruiken om context toe te voegen aan je gesprek of te valideren dat prompts aan bepaalde eisen voldoen.

Notification draait wanneer Claude je waarschuwt, bijvoorbeeld bij het vragen om toestemming om een opdracht te draaien of wanneer input nodig is. PermissionRequest triggert wanneer Claude Code een toestemmingsdialoog toont, zodat je het verzoek automatisch namens de gebruiker kunt goedkeuren of weigeren.

Stop en SubagentStop triggeren wanneer Claude klaar is met antwoorden; handig voor eindcontroles of rapportages. Het verschil is dat Stop vuurt wanneer Claude zijn totale antwoord afrondt, terwijl SubagentStop dat doet wanneer een door een tool gestarte helper (een “subagent”) klaar is.

De overige gebeurtenissen, PreCompact en SessionStart, behandelen speciale situaties zoals het opschonen van gesprekken en het initialiseren van sessies.

De overige gebeurtenissen, PreCompact, SessionStart en SessionEnd, behandelen levenscyclusspecifieke situaties. PreCompact draait vlak voordat Claude de gespreksgeschiedenis inkort. ‘SessionStart’ vuurt aan het begin van een nieuwe sessie om standaarden in te stellen, en SessionEnd triggert wanneer de sessie sluit, wat opruimen of eindrapportage mogelijk maakt.

Matchers begrijpen

Matchers zijn de filters die bepalen welke acties van Claude Code een hook triggeren. Technisch gezien zijn het strings die worden geïnterpreteerd als reguliere expressies, dus je kunt exacte matches of flexibelere patronen gebruiken. 

De meest relevante matchers zijn eenvoudige zoals Write (vuurt wanneer Claude een bestand schrijft) of Edit (vuurt bij het bewerken van inhoud), en combinaties zoals Edit|Write om meerdere acties te dekken. 

Je kunt ook prefixpatronen gebruiken zoals Notebook.* om alle tools te matchen die beginnen met “Notebook.” Wil je dat de hook bij elke actie vuurt, gebruik dan de universele regex .*, een lege string ("") of laat matcher leeg.

Omdat matchers hoofdlettergevoelig zijn en alleen op actienamen werken, kun je ze het beste zo specifiek mogelijk houden. Heb je fijnmazigere controle nodig (bijvoorbeeld de hook beperken tot bepaalde bestandstypen), lees dan de JSON-payload die Claude naar de hook doorgeeft en pas daar je eigen regex of voorwaarden toe.

Je eerste hook maken in Claude Code

Claude Code biedt twee manieren om hooks in te stellen: via de interactieve /hooks-opdracht of door configuratiebestanden direct te bewerken. We beginnen met de interactieve aanpak, omdat die gebruiksvriendelijker is.

Met de /hooks-opdracht:

1. Open Claude Code en typ /hooks in de chatinterface

2. Kies je triggerevent (selecteer voor dit voorbeeld PostToolUse)

3. Selecteer "Add new hook" in het menu

4. Stel je matcherpatroon in (voer Write in om bestandschrijven te targeten)

5. Voer je opdracht in:

• Mac: say "Task complete"

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

• Linux: spd-say "Task complete"

6. Sla de configuratie op en ga terug naar Claude Code door drie keer op Esc te drukken

De /hooks-opdracht werkt je instellingenbestand automatisch bij en laadt de configuratie opnieuw. Je kunt /hooks ook op elk moment gebruiken om je bestaande hooks te bekijken of wijzigingen aan te brengen.

Als je liever direct configuratiebestanden bewerkt, staan hooks in ~/.claude/settings.json voor globale instellingen of in .claude/settings.json binnen je projectmap. Voor ons voorbeeld hierboven ziet het er zo uit:

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

Na handmatig bewerken van het bestand, herstart je Claude Code of gebruik je de /hooks-opdracht om je configuratie te herladen. Vanaf nu hoor je een audiomelding telkens wanneer Claude een bestand schrijft.

Je hook testen

Controleer voordat je doorgaat of je hook echt werkt:

1. Vraag Claude om een willekeurig Python-bestand te schrijven (bijv. "Maak een hello.py-bestand dat hello world print")

2. Je zou de audiomelding moeten horen wanneer Claude de schrijfbewerking voltooit

3. Hoor je niets, bekijk dan het transcript van Claude Code door op Ctrl-O te drukken om foutmeldingen te zien

4. Veelvoorkomende problemen zijn: de hook-opdracht is niet gevonden, verkeerde bestandsrechten of syntaxfouten in je configuratiebestand

Als deze basistest werkt, bespaar je later debugtijd bij het bouwen van complexere hooks. Als je net het instellingenbestand handmatig hebt bewerkt, je matcher of event hebt gewijzigd of nieuwe tools hebt geïnstalleerd die je in een hook-opdracht wilt gebruiken, kan het helpen om /hooks opnieuw te openen of Claude te herstarten om de configuratie te herladen.

Dit basispatroon—event, matcher, opdracht—vormt de fundering voor alle hook-automatisering. Je kunt dit uitbreiden door meerdere opdrachten toe te voegen die gelijktijdig draaien wanneer hetzelfde event triggert. Bijvoorbeeld: je wilt misschien zowel een geluid afspelen als een back-up maken wanneer Claude een bestand schrijft. 

Je kunt ook aparte matchers maken voor verschillende tools binnen hetzelfde event, zodat bestandsschrijven andere acties triggert dan code bewerken. Alle hooks die op hetzelfde toolpatroon matchen, draaien parallel. Als je meerdere matchers voor hetzelfde event configureert, draait elke hook wanneer zijn matcher wordt getriggerd.

Werken met hook-inputs

Wanneer Claude Code een hook triggert, stuurt het informatie over wat er net is gebeurd via standard input (stdin), een datastroom die direct naar je opdracht gaat wanneer die draait. Deze data maakt hooks krachtig in plaats van willekeurige scripts die op arbitrary momenten draaien. 

Claude Code verpakt deze informatie als JSON en voert die aan welke opdracht je ook hebt geconfigureerd, of dat nu een eenvoudige terminalopdracht is of een custom script.

Anatomie van hook-inputs

Elke hook ontvangt een JSON-object met basisvelden over de huidige sessie:

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

Laten we elk onderdeel vertalen:

• session_id: identificeert je huidige gesprek

• transcript_path: verwijst naar de gespreksgeschiedenis

• cwd: toont de werkmap

• hook_event_name: vertelt welke gebeurtenis vuurde

Met deze context kunnen je hooks slimme beslissingen nemen: je kunt bijhouden welk gesprek een actie triggerde, zo nodig de volledige chathistorie raadplegen of opdrachten in de juiste map draaien.

Inputvariaties per event

Tool-events zoals PreToolUse en PostToolUse bevatten extra details over de actie; daar worden hooks echt nuttig voor automatisering. In PreToolUse is de tool_input gespecificeerd, en in PostToolUse komt daar de tool_response bij:

{
  "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
  }
}

In de hook-input toont file_path het pad van het bestand dat wordt geschreven of bewerkt, terwijl content de exacte tekst bevat die de tool gaat schrijven. Na uitvoering echoot de response van de tool het definitieve filePath (let op camelCase) om te bevestigen welk bestand daadwerkelijk is aangeraakt, plus een success-vlag die aangeeft of de operatie correct is voltooid. 

Dankzij deze details kunnen je hooks verschillend reageren afhankelijk van wat er werkelijk gebeurde. Je kunt bijvoorbeeld alleen Python-bestanden formatteren, alleen belangrijke mappen back-uppen of alleen meldingen sturen wanneer bepaalde bestandstypen zijn gewijzigd.

Events zoals UserPromptSubmit zijn eenvoudiger omdat ze geen tools omvatten:

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

Let op: UserPromptSubmit-hooks gebruiken geen matchers in hun configuratie. Ze triggeren op alle prompts, niet op tooloperaties. Dit maakt ze perfect voor het loggen van gesprekken, automatisch projectcontext toevoegen of prompts valideren voordat Claude ze verwerkt.

Hook-input in de praktijk lezen

Laten we een hook maken die elke gebruikersprompt logt. Dit helpt voorkomen dat je kwijtraakt wat je Claude hebt gevraagd, zeker tijdens lange codesessies. Eerst de hookconfiguratie:

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

Maak vervolgens het Python-script op ~/.claude/log_prompts.py met de volgende inhoud:

#!/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)

Het script leest de JSON-data die Claude Code verstuurt en logt de prompt met de sessiecontext. Dit levert een doorzoekbare geschiedenis op van je interacties, wat van onschatbare waarde is wanneer je weken later wilt terughalen hoe je een probleem hebt opgelost.

Werken met hook-outputs

Nadat je hook-opdracht draait, moet die aan Claude Code doorgeven wat er gebeurde en of alles normaal kan doorgaan. Dat besturingsmechanisme maakt van hooks krachtige workflow-automatisering die het gedrag van Claude kan sturen. Dit gebeurt via drie kanalen: standard output (stdout), standard error (stderr) en exitcodes.

Outputkanalen en exitcodes

Standard output (stdout) staat voor normale uitvoer. Als je bijvoorbeeld iets print, gaat dat naar stdout. Voor de meeste hooks is dit wat verschijnt in het transcript van Claude Code wanneer je op Ctrl-O drukt, zodat je een log hebt van wat je automatisering deed zonder het hoofdgesprek te vervuilen.

Standard error (stderr) verwijst naar foutmeldingen. Je kunt naar stderr schrijven met 

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

• Command line: echo "message" >&2

Het belangrijkste verschil is dat stderr direct naar Claude kan worden gestuurd voor automatische verwerking, zodat het kan reageren op problemen die je hooks detecteren.

Exitcodes vertellen Claude Code wat er daarna moet gebeuren:

• Exitcode 0: Succes (toont stdout aan de gebruiker)

• Exitcode 2: Blokkerende fout (stuurt stderr naar Claude)

• Exitcode 3: Uitgestelde uitvoering (geeft aan dat de opdracht zonder fout is voltooid, maar dat de effecten worden uitgesteld tot aan aanvullende voorwaarden is voldaan) 

• Andere codes: Niet-blokkerende fout (toont stderr aan de gebruiker, maar gaat door)

Dit systeem geeft je fijnmazige controle over wanneer Claude moet stoppen, doorgaan of feedback moet krijgen over wat je automatisering ontdekte. Laten we voorbeelden bekijken voor de twee belangrijkste exitcodes.

Exitcode 0: normale werking

De meeste hooks gebruiken exitcode 0 om aan te geven dat alles in orde is. Hier is een complete hook die bestandsbewerkingen logt en de gebruiker een melding geeft:

{
  "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')\""
          }
        ]
      }
    ]
  }
}

Deze hook draait twee opdrachten: loggen naar een bestand en vervolgens een bericht printen in het transcript. Er zijn veel manieren om dit te doen, maar deze aanpak is cross-platform en voorkomt afhankelijkheid van commandline-specifieke zaken.

Omdat er geen expliciete exitcode is, is de standaardwaarde 0. Het geprinte bericht verschijnt in het transcript van Claude Code en geeft je feedback dat het loggen is gelukt. Dit patroon is perfect om audittrails te bouwen of bij te houden welke wijzigingen Claude in de loop der tijd in je project aanbrengt.

Exitcode 2: blokkeren met feedback

Exitcode 2 stuurt je foutbericht rechtstreeks naar Claude, zodat het automatisch kan reageren. Hier worden hooks een veiligheidsmechanisme in plaats van alleen automatisering. Hier is een hook die gevaarlijke bestandsoperaties blokkeert:

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

Je moet het beveiligingsscript aanmaken op ~/.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

Wanneer deze hook een gevaarlijk pad detecteert, sluit hij af met code 2. Claude Code stuurt het stderr-bericht naar Claude, die je vervolgens kan uitleggen waarom de operatie is geblokkeerd en alternatieven kan voorstellen. Zo voorkom je per ongeluk schade aan systeembestanden terwijl Claude op de hoogte blijft van je beveiligingsbeleid.

Een slimme meldingshook bouwen voor Claude Code

Laten we een verbeterde meldingshook bouwen die inputverwerking combineert met slimme outputafhandeling. Dit lost het ruisprobleem op van onze oorspronkelijke hook die bij elke bestandswijziging meldde:

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

Maak het meldingsscript op ~/.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)

Deze hook leest de input om te begrijpen welk bestand is gewijzigd, bepaalt de belangrijkheid van meldingen op basis van het bestandstype, gebruikt stdout om belangrijke wijzigingen in het transcript te loggen, triggert verschillende audioalerts per bestandstype en sluit altijd af met code 0 omdat dit informatieve, niet-blokkerende acties zijn.

De combinatie van inputanalyse en outputsturing levert een hook op die zich intelligent gedraagt op basis van context en de juiste hoeveelheid feedback geeft aan jou en aan Claude Code. In plaats van irritante meldingen voor elk tijdelijk bestand, hoor je alleen over wijzigingen die echt relevant zijn voor je project.

Let op dat dit voorbeeld de say-opdracht gebruikt, die beschikbaar is op macOS. Op Linux kun je bijvoorbeeld notify-send gebruiken, en op Windows een PowerShell-opdracht, om vergelijkbare meldingen te krijgen.

Geavanceerde patronen voor Claude Code Hooks

Naast basis­meldingen en logging kunnen hooks echte problemen in ontwikkelworkflows oplossen waar teams dagelijks mee te maken hebben. Hier zijn enkele ideeën die je kunt aanpassen aan je eigen projecten.

Het mooie is dat je deze hooks niet handmatig hoeft te bouwen. Je kunt Claude Code simpelweg één van de onderstaande promptideeën geven, samen met de Hooks-referentie in de documentatie, en het genereert de relevante code en JSON voor de configuratie.

Elk van deze patronen kan worden afgestemd op je specifieke tools en workflow. Begin met de patronen die je grootste dagelijkse frustraties oplossen en breid je automatisering uit naarmate je comfortabeler wordt met hook-ontwikkeling.

Geavanceerde hooks voor security en compliance

API-sleutelscanner

• Probleem: Per ongeluk secrets committen naar versiebeheer

• Triggers: Vóór het schrijven van elk bestand

• Oplossing: Bestandsinhoud scannen op API-sleutels, tokens en wachtwoorden met regex-patronen

“Maak een Python-script dat de hookinput-JSON leest, de bestandsinhoud extraheert en regex-patronen gebruikt om veelvoorkomende secret-formaten te detecteren zoals api_key=, token: of password=.  Voer voor elke verdachte match lokale verificatie uit en verstuur nooit ruwe secrets extern. 

Verstuur alleen gemaskeerde fragmenten (bijv. 4 voor- en achtervoegtekens behouden) of hashes naar de Anthropic API om verdachte strings te analyseren en te bepalen of het echte secrets zijn of variabelenamen. Sluit af met code 2 en geef Claude feedback over gedetecteerde secrets en veiligere alternatieven.”

Licenseheader-handhaver

• Probleem: Open-sourceprojecten missen vereiste licenseheaders in nieuwe bestanden

• Triggers: Vóór het schrijven van broncodebestanden

• Oplossing: Valideren dat nieuwe .py, .js, .java-bestanden de juiste licentietekst bevatten

“Parse de hookinput om de bestandsinhoud te krijgen en controleer of de eerste 10 regels licentietekst bevatten via stringmatching. Voor geavanceerdere validatie kun je de bestandsheader naar Claude sturen via de Anthropic API om te verifiëren of het de juiste copyrightvermeldingen en licentie-informatie bevat. Blokkeer het aanmaken van bestanden met exitcode 2 als headers ontbreken, en geef Claude het juiste licentiesjabloon om toe te voegen.”

Bescherming van productie­bestanden

• Probleem: Per ongeluk kritieke systeemconfiguratiebestanden wijzigen

• Triggers: Vóór het bewerken van bestanden in gevoelige mappen

• Oplossing: Wijzigingen blokkeren in /etc/, nginx.conf, database.yml en andere kritieke configuraties

“Haal het bestandspad uit de hookinput-JSON en controleer of het overeenkomt met patronen zoals /etc/, production.yml of andere kritieke bestandsnamen. Gebruik de API van Claude om het bestandspad te analyseren en te bepalen of het een configuratiebestand is dat productiesystemen kan beïnvloeden. Sluit af met code 2 en geef specifieke richtlijnen over veiligere ontwikkelpraktijken wanneer gevaarlijke paden worden gedetecteerd.”

Afbeeldingsoptimizer

• Probleem: Grote afbeeldingsbestanden vertragen apps en repositories

• Triggers: Na het toevoegen van nieuwe afbeeldingsbestanden

• Oplossing: PNG/JPEG-bestanden comprimeren met behoud van visuele kwaliteit

“Parse de hookinput om het bestandspad te krijgen en controleer via extensies of het een afbeelding is. Draai compressietools zoals imageoptim of roep de TinyPNG API aan om de afbeelding te comprimeren met behoud van kwaliteit. Log de compressieresultaten naar stdout zodat je de besparing in bestandsgrootte kunt zien in het transcript van Claude.”

Geavanceerde hooks voor versiebeheerautomatisering

Git-branchvalidator

• Probleem: Teamleden pushen per ongeluk naar beschermde branches

• Triggers: Vóór elke schrijf- of bewerkoperatie

• Oplossing: De huidige Git-branch controleren en operaties blokkeren op main/master/production

“Gebruik een simpele bash-opdracht git branch --show-current om de huidige branchenaam op te halen en vergelijk die met een lijst van beschermde branches. Als je op een beschermde branch zit, sluit af met code 2 en stuur Claude een foutbericht met uitleg over het branchbeschermingsbeleid. Voor complexe naamgevingsregels kun je de API van Claude gebruiken om branchnamen te analyseren en te bepalen of ze aan beschermingspatronen voldoen.”

Slimme autocommit

• Probleem: Vergeten om te committen of slechte commitberichten schrijven

• Triggers: Na elke bestandswijziging

• Oplossing: Wijzigingen automatisch stagen en committen met AI-gegenereerde beschrijvende berichten

“Lees de gewijzigde bestandspaden uit de hookinput, draai git diff om de veranderingen op te halen en stuur de diff naar de API van Claude met een prompt die om een bondig commitbericht vraagt. Gebruik het gegenereerde bericht met git add en git commit om de wijzigingen automatisch te committen. Neem bestandsnamen en wijzigingstypen op in de API-prompt zodat commitberichten de conventionele commit-standaarden volgen.”

Documentatiegenerator

• Probleem: API-documentatie die niet synchroon loopt met codewijzigingen

• Triggers: Na het wijzigen van interfacebestanden (controllers, models, API’s)

• Oplossing: Documentatietools zoals JSDoc, Sphinx of OpenAPI-generators automatisch draaien

“Controleer het gewijzigde bestandspad om te bepalen of het om een API-endpoint, model of interfacebestand gaat via patroonmatching. Stuur de bestandsinhoud naar de API van Claude met het verzoek om API-wijzigingen te extraheren en documentatie-updates te genereren. Draai de passende documentatietool (jsdoc, sphinx-build, enz.) en commit de bijgewerkte documentatie automatisch.

Geavanceerde hooks voor samenwerking en integratie

Slack-integratie

• Probleem: Het team is niet op de hoogte van belangrijke wijzigingen in gedeelde codebases

• Triggers: Wanneer meldingen worden verstuurd voor belangrijke operaties

• Oplossing: Opgemaakte berichten posten naar teamkanalen met bestandsnamen en samenvattingen van wijzigingen

“Haal bestandsinformatie uit de hookinput en filter op belangrijke bestandstypen zoals broncode of configuratiebestanden. Gebruik de API van Claude om een leesbare samenvatting van de wijzigingen te genereren op basis van bestandsnamen en -typen. Stuur het opgemaakte bericht naar Slack via webhook-URL’s met vermeldingen van teamleden bij kritieke wijzigingen.”

Webhook-dispatcher

• Probleem: Handmatige CI/CD-triggers zorgen voor vertragingen in deployment

• Triggers: Wanneer specifieke events optreden (configwijzigingen, deploymentbestanden gewijzigd)

• Oplossing: Externe API’s aanroepen om builds, deployments of andere geautomatiseerde processen te starten

“Vergelijk het gewijzigde bestandspad met patronen zoals Dockerfile, package.json of deploymentconfiguraties om te bepalen of CI/CD moet triggeren. Gebruik de requests-bibliotheek in Python om webhook-URL’s aan te roepen met authenticatieheaders en payloadgegevens over de wijzigingen. Neem bestandspaden en wijzigingsmetadata op in de webhookpayload zodat externe systemen slimme beslissingen kunnen nemen over wat te bouwen of te deployen.”

Statuspagina-updater

• Probleem: Klanten zijn niet op de hoogte van onderhoud of deployment-activiteiten

• Triggers: Wanneer deployment- of infrastructuurbestanden worden gewijzigd

• Oplossing: Statuspagina’s van services bijwerken met onderhoudsmeldingen

“Parse hookinput op infrastructuurwijzigingen zoals Kubernetes-manifests of Terraform-configs via bestands­padpatronen. Genereer onderhoudsberichten met behulp van de API van Claude op basis van het type infrastructuurwijzigingen. Plaats statusupdates naar diensten zoals StatusPage.io of PagerDuty via hun REST-API’s met de juiste incidenttypes en geschatte duur.”

Teamstatus-melder

• Probleem: Conflicten wanneer meerdere developers onbewust aan dezelfde features werken

• Triggers: Bij de start van een nieuwe Claude Code-sessie

• Oplossing: Teamkanalen waarschuwen dat je begint aan een specifiek project of component

“Lees de projectmap uit de hookinput en gebruik de API van Claude om recente bestanden of gitgeschiedenis te analyseren om te begrijpen wat voor werk wordt gedaan. Stuur een opgemaakt bericht naar teamcommunicatiekanalen met je naam, projectnaam en focusgebied. Voeg de geschatte duur toe en nodig teamleden uit om af te stemmen als zij aan gerelateerde features werken.”

Conclusie

Claude Code Hooks veranderen onvoorspelbare AI-codeassistenten in geautomatiseerde workflows die draaien precies wanneer je ze nodig hebt. In deze tutorial heb je geleerd hoe je hooks instelt met zowel de interactieve /hooks-opdracht als handmatige configuratie, hoe je de JSON-inputdata begrijpt die slimme automatisering mogelijk maakt en hoe je het gedrag van Claude aanstuurt via exitcodes en gestructureerde outputs. 

De praktische patronen die we hebben behandeld, omvatten security-validators die gevaarlijke operaties blokkeren en slimme meldingen die ruis verminderen. Deze voorbeelden laten zien hoe hooks echte ontwikkelproblemen oplossen, terwijl jij volledige controle houdt over je AI-assistent. Nu je de basis begrijpt, kun je automatisering bouwen die aansluit op de specifieke workflowbehoeften van jouw team. 

Wil je meer leren over werken met AI-tools? Bekijk DataCamps Understanding Prompt Engineering-cursus, die promptstrategieën behandelt die direct aansluiten bij hook-ontwikkeling. Voor bredere AI-codeskills kun je onze Intermediate ChatGPT-cursus proberen om de vaardigheden te ontwikkelen die AI-assistenten betrouwbaardere partners maken in je ontwikkelworkflow.