Claude Code hooks in 2026: een praktische handleiding

Claude Code hooks zijn door de gebruiker gedefinieerde shell-commando's, HTTP-aanroepen of LLM-prompts die automatisch worden uitgevoerd op vaste punten in de levenscyclus van Claude Code: voordat een tool draait, nadat een bestand is bewerkt, wanneer een sessie begint of wanneer Claude een beurt afrondt. Ze bestaan om bepaalde acties deterministisch te maken. In plaats van te hopen dat het model eraan denkt om je code te formatteren of een destructief commando over te slaan, dwingt een hook de regel elke keer af. Deze handleiding behandelt wat Claude Code hooks zijn, de events waarop ze afgaan, hoe je je eerste hook instelt, een werkend voorbeeld dat je kunt kopiëren en wanneer je een hook kiest boven een skill of subagent.

We draaien de contentpijplijn van deze site op Claude Code, dus hooks horen bij ons dagelijkse gereedschap. De onderstaande patronen zijn degene die je als eerste wilt leren.

Wat zijn Claude Code hooks?

Een hook is een regel die door code wordt afgedwongen in plaats van door instructies. Alles wat je in een CLAUDE.md-bestand of een prompt zet, is een suggestie die het model in principe kan negeren of vergeten. Een hook is niet optioneel: wanneer het event afgaat, draait de hook, punt uit. Volgens Anthropics hooks-documentatie is een hook „een door de gebruiker gedefinieerd shell-commando, HTTP-endpoint of LLM-prompt dat automatisch wordt uitgevoerd op specifieke punten in de levenscyclus van Claude Code”.

Dat onderscheid is waar het om draait. Als je wilt dat je linter na elke bewerking draait, werkt een prompt met „draai altijd de linter” meestal wel; een PostToolUse-hook draait hem elke keer, zonder afhankelijk te zijn van het oordeel van het model. Hooks zijn hoe je van „Claude doet meestal X” een „Claude doet altijd X” maakt. Veelvoorkomende taken zijn het automatisch formatteren van bestanden, het blokkeren van riskante shell-commando's, het sturen van een desktopmelding wanneer Claude invoer nodig heeft en het injecteren van verse context (zoals de huidige git-branch) aan het begin van een sessie.

Wanneer hooks afgaan: de levenscyclus-events

Claude Code biedt meer dan dertig levenscyclus-events waarop je kunt inhaken, maar een handvol dekt vrijwel elk echt gebruiksscenario. Elk event geeft je hook een JSON-payload via stdin die beschrijft wat er gebeurt.

Event	Gaat af wanneer	Typisch gebruik
UserPromptSubmit	Je een prompt verstuurt, voordat Claude hem leest	Context injecteren, geheimen in een prompt blokkeren
PreToolUse	Voordat een tool draait	Een commando blokkeren of toetsen; kan de actie weigeren
PostToolUse	Nadat een tool is geslaagd	Code formatteren, tests draaien, linten
SessionStart	Een sessie begint of wordt hervat	Branch-, ticket- of omgevingscontext laden
Stop	Claude klaar is met antwoorden	„tests moeten slagen voordat je stopt” afdwingen
SubagentStop	Een subagent klaar is	De uitvoer van een subagent valideren
Notification	Claude een melding stuurt	Desktopwaarschuwingen wanneer invoer nodig is

De twee die je het meest zult gebruiken zijn PreToolUse (om dingen te voorkomen) en PostToolUse (om te reageren nadat ze zijn gebeurd). Een matcher-veld laat elke hook specifieke tools aanspreken, zodat een formatter alleen bij Edit en Write afgaat, terwijl een commandobewaker alleen bij Bash afgaat.

Hoe stel je je eerste hook in

Hooks leven in een hooks-blok binnen een instellingenbestand. Waar je dat bestand plaatst, bepaalt de reikwijdte ervan:

Bestand	Reikwijdte	Deelbaar
~/.claude/settings.json	Elk project op je machine	Nee
.claude/settings.json	Eén project	Ja, commit het naar de repo
.claude/settings.local.json	Eén project, privé	Nee, uitgesloten via gitignore

De structuur nest drie niveaus: het event, een matcher-groep die filtert op welke tools het van toepassing is, en de handler die het eigenlijke werk doet. Hier is de desktopmelding-hook uit Anthropics instelgids, die je waarschuwt zodra Claude op je wacht:

{
  "hooks": {
    "Notification": [
      {
        "matcher": "",
        "hooks": [
          { "type": "command", "command": "notify-send 'Claude Code' 'Waiting for your input'" }
        ]
      }
    ]
  }
}

Voeg dat toe aan .claude/settings.json, herstart de sessie en de hook is actief. Een lege matcher betekent „match alles”. Dat is het hele mentale model: kies een event, verklein het optioneel met een matcher en richt het op een commando.

Een werkend voorbeeld: bewerkingen formatteren en riskante commando's blokkeren

Twee hooks verdienen zich terug in vrijwel elk project. De eerste formatteert elk bestand dat Claude aanraakt; de tweede weigert destructieve shell-commando's uit te voeren.

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          { "type": "command", "command": "prettier --write \"$CLAUDE_FILE_PATHS\" 2>/dev/null || true" }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          { "type": "command", "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/block-rm.sh" }
        ]
      }
    ]
  }
}

De PreToolUse-bewaker is een klein script dat het voorgestelde commando leest en beslist of het wordt toegestaan. Hier doen exitcodes ertoe: exit 0 betekent „geen bezwaar, ga door”, terwijl exit 2 een blokkerende fout is die de tool stopt en je bericht terugkoppelt naar Claude. Je kunt ook gestructureerde JSON afdrukken voor fijnere controle:

#!/bin/bash
# .claude/hooks/block-rm.sh
COMMAND=$(jq -r '.tool_input.command')
if echo "$COMMAND" | grep -qE 'rm -rf|:(){:|:&};:'; then
  jq -n '{ hookSpecificOutput: {
    hookEventName: "PreToolUse",
    permissionDecision: "deny",
    permissionDecisionReason: "Destructive command blocked by project hook"
  }}'
  exit 0
fi
exit 0

Nu kan Claude in dit project fysiek geen rm -rf uitvoeren, en elk bewerkt bestand komt geformatteerd naar buiten, zonder dat een van beide gedragingen afhangt van of het model eraan denkt.

Prompt-gebaseerde en agent-gebaseerde hooks (nieuw in 2026)

Niet elke regel is een schone ja/nee die je in een shell-script kunt uitdrukken. Anthropic voegde in 2026 twee hooktypes toe voor beslissingen die oordeel vereisen. Een prompt-gebaseerde hook (type: "prompt") stuurt de invoer van de hook naar een Claude-model, standaard Haiku, en laat het model de beslissing teruggeven, handig voor iets als „blokkeer dit commit-bericht als het een klantnaam lekt”. Een agent-gebaseerde hook (type: "agent") start een subagent om iets ingewikkelders te verifiëren voordat Claude verdergaat. Beide ruilen het determinisme van een shell-commando in voor flexibiliteit, en beide kosten een modelaanroep, dus houd ze voor de gevallen die een regex echt niet aankan. Voor de overgrote meerderheid van de hooks is een gewone command sneller, gratis en volledig voorspelbaar.

Hooks versus skills, subagents en CLAUDE.md

Claude Code geeft je verschillende uitbreidingspunten, en de veelgemaakte fout is de verkeerde gebruiken. De scheidslijn is determinisme.

• Hooks dwingen een regel af met code. Gebruik ze wanneer iets elke keer moet gebeuren, ongeacht wat het model beslist: formatteren, vangrails, meldingen, contextinjectie.
• Skills geven Claude herbruikbare instructies en scripts die het kiest toe te passen wanneer een situatie past. Ze breiden de mogelijkheden uit, niet de afdwinging.
• Subagents voeren werk uit in een geïsoleerde context zodat een grote taak de hoofdthread niet overspoelt. Ze gaan over context, niet over regels.
• CLAUDE.md is blijvende sturing die het model leest en meestal volgt, maar kan overrulen.

Als je instructie steeds wordt genegeerd, is dat het signaal om hem te promoveren van een CLAUDE.md-regel naar een hook. Hooks passen ook van nature bij MCP-servers: een hook kan een MCP-tool aanroepen, of afgaan bij het gebruik van een MCP-tool, om Claude aan je bestaande systemen te koppelen.

Is het veilig? Hooks draaien met al je rechten

Ja, met één serieuze kanttekening: hooks voeren willekeurige commando's op je machine uit met de rechten van je gebruiker, automatisch en zonder bevestigingsvraag. Anthropics gids is er duidelijk over dat jij als enige verantwoordelijk bent voor wat je hooks doen, en dat een onzorgvuldige hook bestanden kan verwijderen of data kan beschadigen. Plak nooit een hookconfiguratie van een niet-vertrouwde bron zonder eerst elk commando te lezen, houd gedeelde hooks in een gecommitte .claude/settings.json zodat teamgenoten ze kunnen beoordelen, en geef de voorkeur aan blokkerende bewakers boven alles wat uit zichzelf schrijft of verwijdert. Behandel een hook zoals je elk script zou behandelen dat onbeheerd draait.

Veelgestelde vragen

Waarvoor kun je Claude Code hooks gebruiken?

De meest voorkomende toepassingen zijn automatisch formatteren en linten na bewerkingen, het blokkeren van gevaarlijke of beleidsstrijdige commando's, het draaien van tests voordat Claude een beurt afrondt, het sturen van desktopmeldingen wanneer Claude invoer nodig heeft en het injecteren van context (git-branch, ticketnummer, omgeving) bij het starten van een sessie.

Wat is het verschil tussen een hook en een CLAUDE.md-regel?

Een CLAUDE.md-regel is sturing die het model leest en meestal volgt, maar kan negeren of vergeten. Een hook wordt door code afgedwongen en draait elke keer dat zijn event afgaat. Gebruik CLAUDE.md voor voorkeuren en hooks voor alles wat gegarandeerd moet zijn.

Hoeveel hook-events zijn er, en waar staat de volledige lijst?

Claude Code biedt meer dan dertig levenscyclus-events, van SessionStart tot PreToolUse, PostToolUse, Stop en subagent-events. De volledige, actuele lijst met invoer- en uitvoerschema's staat in de officiële hooks-referentie.

Vertragen hooks Claude Code?

Commando-hooks zijn doorgaans snel en alle overeenkomende hooks draaien parallel, dus de overhead is klein. Prompt-gebaseerde en agent-gebaseerde hooks voegen een modelaanroep toe en zijn trager, dus reserveer ze voor beslissingen die een shell-script niet kan nemen.

Bronnen

• Claude Code Docs — Hooks-referentie: officiële lijst van levenscyclus-events, configuratiestructuur, matchers, invoerschema, exitcodes en JSON-uitvoervelden.
• Claude Code Docs — Acties automatiseren met hooks (gids): doorloop van de eerste hook, prompt-gebaseerde en agent-gebaseerde hooks, en de beveiligingswaarschuwing dat hooks met je rechten draaien.