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 herhaalt dezelfde herinneringen keer op keer. Met Claude Code Hooks kun je deze reminders automatiseren door shell-opdrachten automatisch uit te voeren op specifieke punten in je workflow.

In deze tutorial laat ik zien hoe je hooks instelt voor codeformattering, testuitvoering, meldingen en bestandsbescherming. Je bouwt een automatiseringssysteem dat je ontwikkelstandaarden afdwingt zonder handmatige tussenkomst.

Voor meer over Claude Code, bekijk onze gids met best practices voor Claude Code en onze tutorial over Claude Skills. Wil je leren hoe je instructies op projectniveau configureert, zie dan onze gids over het schrijven van een CLAUDE.md.

TL;DR

• Claude Code Hooks zijn shell-opdrachten die automatisch draaien op specifieke momenten in de levenscyclus van Claude Code (voor/na tool-calls, bij sessiestart, wanneer Claude stopt)

• Configureer ze in .claude/settings.json (project) of ~/.claude/settings.json (globaal) met JSON met events, matchers en commands

• Gebruik PreToolUse-hooks om gevaarlijke acties te blokkeren vóór ze plaatsvinden (exitcode 2 = blokkeren)

• Gebruik PostToolUse-hooks voor opruimtaken zoals formatteren, linten of tests draaien nadat Claude code schrijft

• Hooks ontvangen JSON-context op stdin en communiceren resultaten via exitcodes, stdout en stderr

Wat zijn Claude Code Hooks?

Claude Code Hooks zijn shell-opdrachten die automatisch worden uitgevoerd wanneer specifieke events optreden tijdens je AI-codingsessie. Zie ze als geautomatiseerde triggers die jouw scripts op precies de juiste momenten uitvoeren—vóórdat Claude een bestand schrijft, nadat het een opdracht heeft uitgevoerd, of wanneer het je een melding stuurt.

Het systeem werkt door de acties van Claude Code te monitoren en ze te vergelijken met regels die je in een configuratiebestand definieert. Wanneer er een match is, draait je opgegeven commando met toegang tot context over wat er net gebeurde. Dit geeft je controle over het gedrag van Claude en laat je repetitieve taken automatiseren die anders handmatige tussenkomst vereisen.

Hier is een basis-hook die een codeformatter draait elke keer dat Claude een Python-bestand schrijft:

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

Deze hook heeft drie onderdelen: 

• Het event: PostToolUse (nadat Claude een actie afrondt)

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

• Het commando: python -m black . (formatteert Python-bestanden in de huidige map)

De hook ontvangt gedetailleerde informatie over wat Claude zojuist heeft gedaan via JSON-gegevens die naar de invoer van het script worden gestuurd, zodat je geavanceerdere automatisering kunt bouwen die reageert op specifieke bestandswijzigingen.

Wil je verder met automatisering in Claude Code, bekijk dan onze tutorial over Claude Code Routines, waarin je leert hoe je hooks en agents periodiek in de cloud laat draaien.

Laten we bekijken hoe je vanaf nul hooks maakt en ze registreert in Claude Code.

Vereisten

Je hebt een paar dingen nodig voordat je begint:

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

• Bekendheid met de commandline: Hooks draaien shell-opdrachten, dus je moet weten hoe je basis-terminalcommando's voor jouw besturingssysteem schrijft

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

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

Je hoeft geen shellscript-expert te zijn, maar begrijpen hoe je commando's als ls, cd en basisbestandshandelingen uitvoert, helpt je de voorbeelden te volgen. 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. Dit proces omvat het kiezen van het juiste event voor jouw behoeften, een eenvoudige regel configureren en deze testen met een basiscommando.

Hook-events begrijpen

Claude Code stelt meer dan 25 hook-events beschikbaar. De tabel hieronder behandelt de 10 die je het vaakst zult gebruiken. Voor de volledige lijst, zie de officiële hooks-referentie.

PreToolUse en PostToolUse zijn de meest voorkomende events. PreToolUse draait vóórdat Claude een actie uitvoert, zoals een bestand schrijven of een commando draaien. Dat maakt het perfect voor validatie of het blokkeren van gevaarlijke handelingen. PostToolUse draait nadat Claude een actie voltooit en is ideaal voor opruimtaken zoals code formatteren of tests draaien.

UserPromptSubmit triggert wanneer je een prompt indient bij Claude, voordat deze 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 als er toestemming nodig is om een commando te draaien of wanneer invoer van jou 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, wat handig is voor laatste controles of het genereren van rapporten. Het verschil is dat Stop afgaat wanneer Claude zijn totale antwoord afrondt, terwijl SubagentStop dat doet wanneer een door een tool gestarte helper (een “subagent”) klaar is met zijn werk.

De overige events, PreCompact, SessionStart en SessionEnd, behandelen situaties in de levenscyclus. PreCompact draait vlak voordat Claude de gespreksgeschiedenis inkort. ‘SessionStart’ gaat af aan het begin van een nieuwe sessie om defaults 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 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 (gaat af wanneer Claude een bestand schrijft) of Edit (gaat af bij bewerken), en combinaties zoals Edit|Write om meerdere acties te dekken. 

Je kunt ook prefixpatronen zoals Notebook.* gebruiken om alle tools te matchen die beginnen met “Notebook”. Wil je dat de hook bij elke actie afgaat, 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 beperken tot bepaalde bestandstypen), lees dan de JSON-payload die Claude in de hook stopt 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 het interactieve /hooks-commando of door configuratiebestanden direct te bewerken. We beginnen met de interactieve aanpak omdat die beginnersvriendelijker is.

Met het /hooks-commando:

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

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

3. Selecteer "Add new hook" in het menu

4. Stel je matcher-patroon in (voer Write in om bestands schrijven te targeten)

5. Voer je commando 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 Esc drie keer in te drukken

Het /hooks-commando werkt je instellingenbestand automatisch bij en laadt de configuratie opnieuw. Je kunt /hooks ook altijd gebruiken om je bestaande hooks te bekijken of aan te passen.

Als je liever direct configuratiebestanden bewerkt, staan hooks in ~/.claude/settings.json voor globale instellingen, .claude/settings.json binnen je projectmap (commit dit in de repo voor team-shared hooks), of .claude/settings.local.json voor persoonlijke hooks die standaard in .gitignore staan. 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 start je Claude Code opnieuw of gebruik je het /hooks-commando om je configuratie te herladen. Vanaf nu hoor je bij elke schrijfbewerking van Claude een audiomelding.

Je hook testen

Controleer vóór je verdergaat 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 afrondt

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

4. Veelvoorkomende issues zijn: het hook-commando is niet gevonden, verkeerde bestandsrechten, of syntaxfouten in je configuratiebestand

Deze basistest laten slagen bespaart je later debugtijd bij complexere hooks. Als je net het instellingenbestand handmatig hebt bewerkt, je matcher of event hebt aangepast, of nieuwe tools hebt geïnstalleerd die je in een hook-commando wil gebruiken, kan het helpen om /hooks opnieuw te openen of Claude te herstarten om de configuratie te herladen.

Dit basispatroon (event, matcher, commando) vormt de basis van alle hook-automatisering. Je kunt dit uitbreiden door meerdere commando's toe te voegen die tegelijk draaien wanneer hetzelfde event triggert. Bijvoorbeeld: 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 codebewerking. 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-invoer

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

Claude Code verpakt deze informatie als JSON en voert die aan welk commando je ook hebt geconfigureerd, of dat nu een simpel terminalcommando is of een custom script.

Anatomie van hook-invoer

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: laat zien welk event is geactiveerd

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

Invoer variaties op basis van events

Tool-events zoals PreToolUse en PostToolUse bevatten extra details over de actie, en dáár worden hooks echt nuttig voor automatisering. In PreToolUse is de tool_input gespecificeerd, en in PostToolUse komt daar 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-invoer 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 respons van de tool het definitieve filePath (let op camelCase) om te bevestigen welk bestand daadwerkelijk is aangeraakt, samen met een success-vlag die aangeeft of de operatie correct is afgerond. 

Dankzij deze details kunnen je hooks verschillend reageren op basis van wat er echt gebeurde. Je kunt 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 dat UserPromptSubmit-hooks geen matchers gebruiken in hun configuratie. Ze triggeren op alle prompts, niet op toolhandelingen. Dit maakt ze perfect voor het loggen van gesprekken, automatisch projectcontext toevoegen of prompts valideren voordat Claude ze verwerkt.

Hook-invoer in de praktijk lezen

Laten we een hook maken die elke gebruikersprompt logt. Dit lost het probleem op dat je kwijtraakt wat je Claude vroeg te doen, vooral tijdens lange codingsessies. Eerst de hook-configuratie:

{
  "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-gegevens die Claude Code stuurt en logt de prompt met de sessiecontext. Dit creëert een doorzoekbare geschiedenis van je interacties, wat van onschatbare waarde is als je weken later wilt terughalen hoe je een probleem hebt opgelost.

Werken met hook-uitvoer

Nadat je hookcommando draait, moet het aan Claude Code vertellen wat er is gebeurd en of er normaal kan worden doorgegaan. Dit controlemecanisme maakt van hooks krachtige workflow-automatisering die het gedrag van Claude kan sturen, in plaats van simpele logtools. Dit gebeurt via drie kanalen: standaarduitvoer (stdout), standaardfout (stderr) en exitcodes.

Uitvoerkanalen en exitcodes

Standaarduitvoer (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 verslag hebt van wat je automatisering deed zonder het hoofdgesprek te vervuilen.

Standaardfout (stderr) verwijst naar foutmeldingen. Je kunt naar stderr schrijven met 

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

• Commandline: echo "message" >&2

Het cruciale verschil is dat stderr direct naar Claude kan worden gestuurd voor automatische verwerking, waardoor 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)

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

Dit systeem geeft je fijne controle over wanneer Claude moet stoppen, doorgaan of feedback moet krijgen over wat je automatisering heeft ontdekt. Laten we kijken naar voorbeelden voor de twee belangrijkste exitcodes.

Exitcode 0: normale werking

De meeste hooks gebruiken exitcode 0 om aan te geven dat alles goed ging. Hier is een volledige hook die bestandsacties logt en de gebruiker meldt:

{
  "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 dingen: loggen naar een bestand en vervolgens een bericht in het transcript printen. Er zijn veel manieren om dit te doen, maar deze aanpak is cross-platform en vermijdt afhankelijkheid van specifieke commandline-details.

Omdat er geen expliciete exitcode is, is de standaard 0. Het geprinte bericht verschijnt in het transcript van Claude Code, zodat je ziet dat het loggen werkte. Dit patroon is perfect voor het opbouwen van audittrails of het bijhouden van welke wijzigingen Claude in de loop van de tijd in je project aanbrengt.

Exitcode 2: blokkeren met feedback

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

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

Je moet het security-checkscript maken 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 actie is geblokkeerd en alternatieven kan voorstellen. Dit voorkomt onbedoelde schade aan systeembestanden terwijl Claude op de hoogte blijft van je beveiligingsbeleid.

Een slimme meldingshook bouwen voor Claude Code

Laten we onze verbeterde meldingshook bouwen die invoer verwerken combineert met slimme uitvoerafhandeling. Dit lost het ruisprobleem op van onze oorspronkelijke hook die bij elke bestandswijziging alarmeerde:

{
  "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 invoer om te begrijpen welk bestand is gewijzigd, bepaalt de meldingsimportantie op basis van bestandstype, gebruikt stdout om belangrijke wijzigingen in het transcript te loggen, triggert verschillende audioalerts op basis van bestandstype en sluit altijd af met code 0 omdat dit informatieve acties zijn, geen blokkerende.

De combinatie van inputanalyse en outputcontrole zorgt voor een hook die zich intelligent gedraagt op basis van context en het juiste niveau van feedback geeft aan jou en aan Claude Code. In plaats van vervelende meldingen voor elk tijdelijk bestand, hoor je alleen over wijzigingen die er echt toe doen voor je project.

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

Veelvoorkomende valkuilen met Claude Code Hooks

Een paar dingen waar de meeste mensen in hun eerste week met hooks tegenaan lopen:

Echo-statements in je shellprofiel breken hooks. Hooks draaien in niet-interactieve shells die je ~/.zshrc of ~/.bashrc laden. Als je profiel onvoorwaardelijke echo-statements bevat, zetten die tekst vóór de hook-stdout en breken ze JSON-parsing. Omhul ze met een check voor een interactieve shell:

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

Stop-hooks kunnen eindeloos blijven lopen. Een Stop-hook die afsluit met code 2 dwingt Claude om door te blijven werken. Als je script stop_hook_active uit de invoer-JSON niet controleert en netjes afsluit wanneer die true is, blijf je draaien tot de timeout. Voeg altijd een vroege exit-guard toe.

Matchers zijn hoofdlettergevoelig. bash matcht niet met Bash. Gebruik exact de toolnaam zoals die in Claude Code verschijnt.

Uitvoer is begrensd tot 10.000 tekens. Als je hook meer genereert, wordt het afgekapt vóórdat het in de context van Claude wordt geïnjecteerd. Houd stdout beknopt en laat alleen zien wat het model nodig heeft.

Verwarring tussen team- en persoonlijke hooks. Hooks in .claude/settings.json worden gedeeld met het team (commit ze in de repo). Voor persoonlijke hooks die je niet wilt delen, gebruik je .claude/settings.local.json, dat standaard in .gitignore staat.

Hooks vs. skills: wanneer gebruik je wat

Hooks en Claude Skills dienen verschillende doelen en werken het best samen. Een skill is een markdownbestand dat Claude leert hoe iets te doen (procedures, conventies, templates). Een hook is een shell-opdracht die een regel deterministisch afdwingt, ongeacht wat Claude beslist.

Het onderscheid is belangrijk: een skill is een suggestie die het model onder druk kan negeren; een hook vuurt elke keer af. Schrijf een skill om de migratieprocedure van je team te documenteren. Schrijf een PostToolUse-hook om de migratielinter te draaien op elk .sql-bestand dat Claude schrijft. De skill maakt Claude competent; de hook maakt Claude aanspreekbaar.

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: je hoeft deze hooks niet handmatig te bouwen. Je kunt Claude Code simpelweg een van de promptideeën hieronder 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 jouw 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

Hooks zijn ideaal om beveiligingsregels en nalevingsstandaarden af te dwingen. Hier zijn vier use-cases.

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 hook-invoer-JSON leest, de bestandsinhoud extraheert en met regex-patronen veelvoorkomende secret-formaten detecteert zoals api_key=, token: of password=.  Voer voor elke verdachte match lokale verificatie uit en stuur nooit ruwe secrets extern. ”

Stuur alleen gemaskeerde fragmenten (bijv. 4 prefix-/suffixtekens 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.”

Licentieheader-handhaver

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

• Triggers: Vóór het schrijven van broncodebestanden

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

“Parse de hook-invoer om de bestandsinhoud op te halen 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 deze de juiste copyright- en licentie-informatie bevat. Blokkeer het aanmaken van het bestand met exitcode 2 als headers ontbreken en geef Claude de juiste licentiesjabloon om toe te voegen.”

Bescherming voor 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 configs

“Haal het bestandspad uit de hook-invoer-JSON en controleer of het matcht 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 productie­systemen kan beïnvloeden. Sluit af met code 2 en geef specifieke richtlijnen over veiligere ontwikkelpraktijken wanneer gevaarlijke paden worden gedetecteerd.”

Afbeeldingsoptimizer

• Probleem: Grote afbeeldingsbestanden die apps en repositories vertragen

• Triggers: Na het toevoegen van nieuwe afbeeldingsbestanden

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

“Parse de hook-invoer om het bestandspad te krijgen en controleer via extensie-matching 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 bestandsomvang in het transcript van Claude ziet.”

Geavanceerde hooks voor versiebeheer-automatisering

Git-workflows en documentatie zijn gebieden waar hooks ook erg nuttig zijn. Laten we wat ideeën bekijken.

Git-branchvalidator

• Probleem: Teamleden die per ongeluk naar beschermde branches pushen

• Triggers: Vóór elke schrijf- of bewerkbewerking op bestanden

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

“Gebruik een eenvoudig bash-commando git branch --show-current om de huidige branchtnaam op te halen en vergelijk die met een lijst beschermde branches. Als je op een beschermde branch zit, sluit dan af met code 2 en stuur Claude een foutmelding die de branchbeschermingsregels uitlegt. Voor complexe naamgevingsregels kun je de API van Claude gebruiken om branchnamen te analyseren en te bepalen of ze matchen met beschermingspatronen.”

Slimme auto-commit

• Probleem: Vergeten 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 hook-invoer, draai git diff om de wijzigingen te krijgen en stuur de diff naar de API van Claude met een prompt voor een beknopt commitbericht. Gebruik het gegenereerde bericht met git add en git commit om de wijzigingen automatisch te committen. Neem bestandsnamen en type wijzigingen op in de API-prompt zodat commitberichten voldoen aan conventionele commit-standaarden.”

Documentatiegenerator

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

• Triggers: Na het wijzigen van interfacebestanden (controllers, modellen, API's)

• Oplossing: Automatisch documentatietools zoals JSDoc, Sphinx of OpenAPI-generators draaien

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

Geavanceerde hooks voor samenwerking en workflow-integratie

Tot slot kunnen hooks helpen om alle teamleden up-to-date te houden.

Slack-integratie

• Probleem: Het team is zich niet bewust van belangrijke wijzigingen in gedeelde codebases

• Triggers: Wanneer meldingen worden verstuurd voor significante acties

• Oplossing: Opgemaakte berichten posten in teamkanalen met bestandsnamen en wijzigingssamenvattingen

“Haal bestandsinformatie uit de hook-invoer en filter op belangrijke bestandstypen zoals broncode of configuratiebestanden. Gebruik de API van Claude om een voor mensen leesbare samenvatting van de wijzigingen te genereren op basis van bestandsnamen en -typen. Verstuur het geformatteerde bericht naar Slack via webhook-URL's met @-mentions van teamleden voor kritieke wijzigingen.”

Webhook-dispatcher

• Probleem: Handmatige CI/CD-triggers die tot deployvertragingen leiden

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

• 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 deploymentconfigs om te bepalen of CI/CD moet triggeren. Gebruik de requests-bibliotheek in Python om webhook-URL's aan te roepen met authenticatieheaders en payloaddata over de wijzigingen. Neem bestandspaden en wijzigingsmetadata op in de webhook-payload zodat externe systemen slimme beslissingen kunnen nemen over wat te bouwen of te deployen.”

Statuspagina-updater

• Probleem: Klanten zijn zich niet bewust van onderhouds- of deploymentactiviteiten

• Triggers: Wanneer deployment- of infrastructuurbestanden zijn aangepast

• Oplossing: Servicestatuspagina's bijwerken met onderhoudsmeldingen

“Parse de hook-invoer op infrastructuurwijzigingen zoals Kubernetes-manifests of Terraform-configs via bestandspadpatronen. Genereer onderhoudsberichten met behulp van de API van Claude op basis van het type detecteerde infrastructuurwijzigingen. Post 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 ontwikkelaars onbewust aan dezelfde features werken

• Triggers: Bij het starten van een nieuwe Claude Code-sessie

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

“Lees de projectmap uit de hook-invoer en gebruik de API van Claude om recente bestanden of git-geschiedenis te analyseren, zodat duidelijk wordt welk type werk wordt gedaan. Stuur een geformatteerd bericht naar teamcommunicatiekanalen met je naam, projectnaam en focusgebied. Neem geschatte werktijd op en nodig teamleden uit om af te stemmen als ze aan gerelateerde features werken.”

Tot slot

Claude Code Hooks veranderen onvoorspelbare AI-coding-assistenten in geautomatiseerde workflows die draaien precies wanneer jij ze nodig hebt. In deze tutorial heb je geleerd hoe je hooks instelt met zowel het interactieve /hooks-commando als handmatige configuratie, hoe je de JSON-invoer begrijpt die intelligente automatisering aandrijft, en hoe je het gedrag van Claude stuurt via exitcodes en gestructureerde uitvoer. 

De praktische patronen die we behandelden omvatten securityvalidators die gevaarlijke acties blokkeren en slimme meldingen die ruis verminderen. Deze voorbeelden laten zien hoe hooks echte ontwikkelproblemen oplossen terwijl jij volledige controle behoudt over je AI-assistent. Nu je de basis begrijpt, kun je automatisering bouwen die past bij de specifieke workflowbehoeften van je team. 

Wil je meer leren over werken met AI-tools, bekijk dan DataCamps Understanding Prompt Engineering-cursus, die promptstrategieën behandelt die direct samengaan met hook-ontwikkeling. Voor bredere AI-codingskills, probeer onze Intermediate ChatGPT-cursus om de vaardigheden te ontwikkelen die AI-assistenten betrouwbaardere partners in je ontwikkelworkflow maken.