Kort Resumé: Claude Code hooks er automatiseringsscripts, der udføres på specifikke livscyklus-punkter under AI-kodningssessioner, hvilket giver udviklere mulighed for at køre brugerdefinerede kommandoer, validere handlinger, formatere kode, sende notifikationer og håndhæve projektregler. Disse hooks integreres med Claudes workflow via begivenheder som SessionStart, PreToolUse og PostToolUse, og understøtter kommandobaserede, HTTP-baserede og prompt-baserede eksekveringsmønstre med konfigurerbare timeouts og exit-kodeadfærd.
Claude Codes hook-system transformerer AI-kodeassistenten fra et hjælpsomt værktøj til et fuldt automatiseret udviklingsmiljø. De fleste udviklere er ikke klar over omfanget af kontrol, der er tilgængelig gennem hooks.
Her er sagen – hooks handler ikke kun om at køre scripts efter filredigeringer. De giver aflytningspunkter gennem Claudes hele beslutningsproces. Før den udfører en kommando. Efter et værktøjsopkald mislykkes. Når den har brug for tilladelse. Selv før behandling af brugerprompter.
Denne guide dækker alt, hvad den officielle dokumentation giver, plus praktiske mønstre, som community-diskussioner afslører faktisk virker i produktionsmiljøer.
Hvad Claude Code Hooks Faktisk Gør
Ifølge den officielle Claude Code-dokumentation er hooks brugerdefinerede shell-kommandoer, HTTP-endpoints eller prompt-injektioner, der udføres på specifikke punkter i Claude Codes livscyklus. De modtager struktureret JSON-input via stdin og styrer workflowet gennem exit-koder eller HTTP-svar.
Automatiseringen går dybere end de fleste guider antyder. Hooks kan helt blokere værktøjsudførelse, injicere yderligere kontekst i Claudes ræsonnement, udløse eksterne tjenester og håndhæve valideringsregler, som Claude skal respektere.
Der findes tre kerne hook-typer:
- Kommando hooks: Shell-scripts, der kommunikerer via stdout, stderr og exit-koder
- HTTP hooks: Fjern-endpoints, der modtager POST-anmodninger og returnerer JSON-svar
- Prompt hooks: Dynamiske instruktioner injiceret i Claudes kontekst ved specifikke begivenheder
Hver type tjener forskellige automationsmønstre. Kommando hooks håndterer lokal validering og formatering. HTTP hooks integreres med eksterne tjenester og databaser. Prompt hooks ændrer Claudes adfærd uden eksterne processer.
Hook Livscyklus og Begivenhedssystem
Den officielle dokumentation definerer flere hook-begivenheder (SessionStart, UserPromptSubmit, PreToolUse, PermissionRequest, PostToolUse, PostToolUseFailure, Notification og andre), der udløses under Claude Codes eksekveringsflow. At forstå, hvornår hver enkelt udløses, bestemmer, hvilken automatisering der bliver mulig.
| Begivenhed | Hvornår den udløses | Kan blokere |
|---|---|---|
| SessionStart | Når en session starter eller genoptages | Nej |
| UserPromptSubmit | Når du sender en prompt, før Claude behandler den | Ja |
| PreToolUse | Før et værktøjsopkald udføres | Ja |
| PermissionRequest | Når en tilladelsesdialog vises | Ja |
| PostToolUse | Efter et værktøjsopkald lykkes | Nej |
| PostToolUseFailure | Efter et værktøjsopkald mislykkes | Nej |
| Notification | Når Claude Code sender en notifikation | Nej |
| SubmitMessage | Når Claude sender en besked til brugeren | Nej |
| ContextCompaction | Når kontekstvinduet nærmer sig grænserne | Nej |
Blokeringsevnen betyder mest. PreToolUse hooks kan forhindre farlige operationer, før de udføres. Exit-kode 1 blokerer handlingen. Exit-kode 0 tillader den. Exit-kode 2 får Claude til at genoverveje.
Men vent. PostToolUse hooks kan ikke fortryde handlinger, da værktøjet allerede er udført. Denne begrænsning former, hvordan valideringslogik struktureres. Kritiske kontroller hører hjemme i PreToolUse. Oprydning og formatering hører hjemme i PostToolUse.
Gennemse AI-Værktøjsfordele, Mens Du Opsætter Claude Code
Hvis du arbejder med Claude Code hooks, vælger du måske også andre AI-værktøjer omkring dit workflow. Get AI Perks samler startup-kreditter og softwarerabatter til AI- og cloud-værktøjer ét sted. Platformen inkluderer over 200 tilbud med fordelbetingelser og claim-vejledning for hver enkelt.
Leder Du Efter Fordele for Claude eller Andre AI-Værktøjer?
Tjek Get AI Perks for at:
- gennemse tilbud på Claude og andre AI-værktøjer
- sammenligne fordelbetingelser, før du ansøger
- finde startup-rabatter på tværs af din værktøjsstak
👉 Besøg Get AI Perks for at udforske aktuelle AI-softwarefordele.
Konfiguration og Filstruktur
Hooks defineres i .claude/settings.json-filen inden for et projekt. Konfigurationsskemaet understøtter globale hooks og værktøjsspecifikke matchere, der filtrerer, hvornår hooks udføres.
Grundlæggende kommandohook-struktur:
| { “hooks”: [ { “event”: “PostToolUse”, “command”: “prettier –write”, “args”: [“${file}”] } ] } |
Variablen ${file} udvides til den faktiske filsti fra værktøjets input. Ifølge den officielle dokumentation understøtter hooks disse variabeludvidelser i kommando- og argumentfelter.
Hook Placeringshierarki
Claude Code tjekker flere placeringer for hook-definitioner med en klar forrangsorden:
- Projekt-niveau: .claude/settings.json i det aktuelle arbejdsområde
- Bruger-niveau: ~/.claude/settings.json for alle sessioner
- Plugin-leverede: Hooks bundtet med installerede plugins
Projekthooks tilsidesætter brugerhooks for samme begivenhed. Dette giver mulighed for projektspecifikke formateringsregler, samtidig med at globale notifikationshåndteringer opretholdes.
Matcher Mønstre for Selektiv Udførelse
Matcher-systemet filtrerer hooks til specifikke værktøjer eller betingelser. Uden matchere udløses hooks for hver forekomst af deres begivenhed.
| { “hooks”: [ { “event”: “PreToolUse”, “matcher”: { “toolName”: “edit_file”, “pathPattern”: “src/**/*.ts” }, “command”: “./scripts/validate-typescript.sh” } ] } |
Feltet pathPattern accepterer glob-syntaks. Feltet toolName matcher mod Claude's indbyggede værktøjer som edit_file, execute_command, read_file og create_directory.
Community-diskussioner afslører, at matcher-kombinationer fungerer med OG-logik. Alle specificerede matchere skal matche, for at hooken udføres.
Kommando Hooks: Shell Script Integration
Kommando hooks udfører shell-kommandoer eller scripts med struktureret JSON-input. De repræsenterer den mest almindelige hook-type til lokal automatisering.
Den officielle dokumentation angiver, at kommando hooks modtager JSON via stdin med denne struktur:
| { “event”: “PreToolUse”, “toolName”: “edit_file”, “toolInput”: { “path”: “src/app.ts”, “content”: “…” }, “sessionId”: “abc123”, “turnId”: “turn-456” }Scripts parser dette input for at træffe beslutninger. En Python-valideringshook kunne se således ud:#!/usr/bin/env python3 import sys import json input_data = json.load(sys.stdin) tool_input = input_data.get(‘toolInput’, {}) file_path = tool_input.get(‘path’, ”) if file_path.startswith(‘protected/’): print(“Cannot edit protected files”, file=sys.stderr) sys.exit(1) sys.exit(0) |
Exit-kode 0 tillader operationen. Exit-kode 1 blokerer den og viser stderr-beskeden til Claude. Exit-kode 2 udløser speciel adfærd afhængigt af begivenheden.
Exit Kode 2 Adfærd
Ifølge den officielle reference for hooks har exit-kode 2 begivenhedsspecifik betydning (PreToolUse: blokerer og beder om genovervejelse; UserPromptSubmit: giver kontekst uden blokering; PermissionRequest: blokerer tilladelse):
- PreToolUse: Blokerer værktøjet og beder Claude om at genoverveje med stderr-beskeden som kontekst
- UserPromptSubmit: Giver stderr-outputtet som yderligere kontekst uden blokering
- PermissionRequest: Blokerer tilladelsesgivningen
Dette skaber en mellemvej mellem hård blokering og tilladelse. Claude modtager feedback om, hvorfor handlingen kan være problematisk, og kan justere sin tilgang.
Asynkrone Kommando Hooks
Flaget async: true kører hooks i baggrunden uden at blokere Claudes workflow. Dette er vigtigt for langsomme operationer som udrulningsnotifikationer eller metrikindsamling.
| { “event”: “PostToolUse”, “matcher”: { “toolName”: “execute_command” }, “command”: “./scripts/log-to-analytics.sh”, “async”: true, “timeout”: 30 } |
Når en asynkron hook udløses, starter Claude Code processen og fortsætter straks. Timeout-feltet angiver den maksimale eksekveringstid i sekunder. Hvis det ikke er specificeret, bruger asynkrone hooks en standard timeout på 10 minutter.
Ærligt talt: asynkrone hooks kan ikke blokere operationer, da de kører, efter at Claude er fortsat. De fungerer til logning, notifikationer og oprydning – ikke validering.
HTTP Hooks: Integration af Eksterne Tjenester
HTTP hooks sender JSON-payloads til fjern-endpoints og parser svar for at kontrollere beslutninger. De muliggør integration med valideringstjenester, databaser og tredjepartsværktøjer.
Grundlæggende HTTP hook konfiguration:
| { “event”: “PreToolUse”, “url”: “api.example.com/validate”, “headers”: { “Authorization”: “Bearer ${API_TOKEN}” }, “timeout”: 5 } |
Payload-strukturen matcher kommando hook input, men ankommer som HTTP POST-body. Svaret bestemmer Claudes næste handling.
Håndtering af HTTP Svar
Ifølge den officielle dokumentation fortolker HTTP hooks svar baseret på statuskode og brødtekstindhold:
| Statuskode | Effekt | Beskedkilde |
|---|---|---|
| 200 | Tillad operation | Svar-body (valgfrit) |
| 400 | Bloker operation | Svar-body vist til Claude |
| 500 | Hook-fejl, tillad operation | Logget, men ikke vist til Claude |
| Anden | Tillad operation | Hook-fejl blokerer ikke workflowet |
Svar-bodyen kan indeholde et beskedfelt, som Claude ser som kontekst. Dette gør det muligt for valideringstjenester at forklare, hvorfor en operation blev blokeret.
Miljøvariabel Interpolation
HTTP hooks understøtter ${VAR}-syntaks i url, headers og andre strengfelter. Variabler udvides fra miljøet, hvor Claude Code kører.
Ifølge den officielle MCP-dokumentation inkluderer miljøvariabeludvidelse en standard fallback-syntaks: ${VAR:-default} udvides til VAR, hvis den er sat, ellers bruges standardværdien.
Sikkerhedsrestriktion: Ifølge GitHub-issue #28044 kan HTTP hooks kun få adgang til miljøvariabler, der eksplicit er angivet i feltet allowedEnvVars i konfigurationen. Dette forhindrer utilsigtede legitimationsoplysninger i at blive eksponeret.
Prompt Hooks: Kontekst Injektion
Prompt hooks injicerer dynamiske instruktioner i Claudes kontekst ved specifikke begivenheder. De ændrer adfærd uden eksterne processer eller API-kald.
| { “event”: “SessionStart”, “prompt”: “Du arbejder på et TypeScript-projekt. Brug altid strikte null-checks og foretræk async/await frem for promises.” } |
Den injicerede tekst bliver en del af Claudes systeminstruktioner for den pågældende session. Prompt hooks kan også bruge skabelonvariabler, der udvides baseret på begivenhedsdata.
Dynamisk Prompt Generering
Ifølge den officielle dokumentation understøtter prompt hooks kommando-felter, der genererer dynamiske prompts:
| { “event”: “ContextCompaction”, “type”: “prompt”, “command”: “./scripts/generate-context-summary.sh” } |
Kommandoen modtager det standard JSON-input via stdin og udskriver prompt-teksten til stdout. Dette muliggør kontekstbevidst instruktionsgenerering baseret på projektets tilstand.
Agent-baserede Hooks
Agent hooks specificerer en underagent, der håndterer begivenheden i stedet for direkte prompt-injektion. Underagenten modtager kontekst om begivenheden og kan udføre ræsonnement i flere trin.
| { “event”: “PostToolUseFailure”, “agent”: “debugger”, “agentPrompt”: “Et værktøjsopkald mislykkedes. Analyser fejlen og foreslå rettelser.” } |
Den navngivne underagent skal være defineret i projektets konfiguration. Agent hooks muliggør kompleks beslutningslogik, som simpel prompt-injektion ikke kan levere.
Praktiske Hook Mønstre
Community-diskussioner og officielle eksempler afslører specifikke automationsmønstre, der fungerer pålideligt i produktion.
Automatisk Formatering af Kode efter Redigeringer
Det mest almindelige mønster formaterer kode automatisk efter at Claude har redigeret filer:
| { “event”: “PostToolUse”, “matcher”: { “toolName”: “edit_file”, “pathPattern”: “**/*.{js,ts,jsx,tsx}” }, “command”: “prettier”, “args”: [“–write”, “${toolInput.path}”] } |
Variablen ${toolInput.path} udvides til den redigerede filsti. PostToolUse sikrer, at formatering sker efter succesfulde redigeringer, men blokerer ikke Claude's workflow.
Blokering af Modifikation af Beskyttede Filer
PreToolUse hooks håndhæver regler for filbeskyttelse:
| { “event”: “PreToolUse”, “matcher”: { “toolName”: “edit_file” }, “command”: “./scripts/check-protected.sh” } |
Scriptet validerer mål-stien mod beskyttede mønstre og afsluttes med kode 1 for at blokere forbudte redigeringer.
Få Besked, Når Claude Har Brug for Input
Ifølge den officielle workflow-guide kan Notification hooks udløse desktop-alarmer eller sende beskeder til eksterne tjenester:
| { “event”: “Notification”, “command”: “osascript”, “args”: [“-e”, “display notification \”${message}\” with title \”Claude Code\””] } |
Dette udløses, når Claude Code sender en notifikation, herunder når der venter på brugerinput eller efter opgaveafslutning.
Re-injektér Kontekst efter Komprimering
ContextCompaction hooks gendanner vigtig kontekst, når samtalefremdøret fyldes op:
| { “event”: “ContextCompaction”, “type”: “prompt”, “command”: “cat .claude/critical-context.md” } |
Kommandoens output injiceres tilbage i Claude's kontekst efter komprimering, der fjerner ældre beskeder. Dette forhindrer tab af kritiske projektspecifikke instruktioner.
Auditér Konfigurationsændringer
Spor, hvornår Claude ændrer konfigurationsfiler:
| { “event”: “PostToolUse”, “matcher”: { “toolName”: “edit_file”, “pathPattern”: “**/{package.json,.env,*.config.*}” }, “command”: “git”, “args”: [“add”, “${toolInput.path}”], “async”: true } |
Asynkron udførelse forhindrer blokering af Claude, mens git-operationer fuldføres. Dette skaber et revisionsspor af konfigurationsændringer uden manuel staging.
JSON Output og Beslutningskontrol
Kommando hooks kan outputte struktureret JSON for at give detaljeret feedback ud over simple exit-koder. Ifølge den officielle reference muliggør JSON-output multi-felt svar, som Claude fortolker til beslutningstagning.
| { “allowed”: false, “message”: “Denne fil er beskyttet af team-politikken”, “suggestion”: “Opret en ny fil i src/features/ i stedet” } |
Feltet allowed styrer, om operationen fortsætter. Beskeden vises til Claude som kontekst. Feltet suggestion giver alternative tilgange.
For at hooks kan outputte JSON, skal de:
- Skrive gyldig JSON til stdout
- Afslutte med kode 0 (for tilladt) eller 1 (for blokeret)
- Inkludere mindst feltet allowed boolean
Claude Code parser JSON og bruger det til at forbedre feedback-loopet. Exit-koder bestemmer stadig den primære beslutning, men JSON giver rigere kontekst.
Reference for Hook Inputfelter
Alle hooks modtager et JSON-objekt via stdin med fælles felter plus begivenhedsspecifikke data. At forstå det komplette skema muliggør mere sofistikeret hook-logik.
Fælles Inputfelter
Hver hook modtager disse basisfelter:
- event: Hookens begivenhedsnavn (f.eks. “PreToolUse”)
- sessionId: Unik identifikator for den aktuelle Claude-session
- turnId: Identifikator for det aktuelle samtaletræk
- timestamp: ISO 8601 tidsstempel, da begivenheden udløstes
Værktøjs Begivenhedfelter
PreToolUse, PostToolUse og PostToolUseFailure begivenheder inkluderer:
- toolName: Navn på det værktøj, der kaldes (edit_file, execute_command osv.)
- toolInput: Objekt, der indeholder værktøjets inputparametre
- toolResponse: Værktøjsoutputdata (kun PostToolUse)
- error: Fejldetaljer inklusive besked og kode (kun PostToolUseFailure)
toolInput-strukturen varierer efter værktøj. For edit_file indeholder den path og content. For execute_command indeholder den command og args.
Tilladelses Begivenhedfelter
PermissionRequest begivenheder inkluderer:
- permissionType: Type tilladelse anmodet om (file_write, command_execute osv.)
- requestedAction: Specifik handling, der kræver tilladelse
- resourcePath: Filsti eller ressourceidentifikator berørt
MCP Værktøjs Hooks
Ifølge den officielle reference for hooks kan hooks matche mod Model Context Protocol (MCP) værktøjer ved hjælp af mcpTool matcher-feltet. Dette muliggør hook-udførelse, når Claude bruger eksterne værktøjer leveret af MCP-servere.
| { “event”: “PreToolUse”, “matcher”: { “mcpTool”: “database/query” }, “command”: “./scripts/validate-sql.sh” } |
Værdien mcpTool matcher mod værktøjets navn i formatet server-navn/værktøjs-navn. Dette giver mulighed for valideringslogik for databaseforespørgsler, API-kald eller andre eksterne operationer.
GitHub-anmodninger om funktioner indikerer stigende interesse for dybere MCP-integration, herunder hooks, der kan inspicere MCP-servernotifikationer og reagere på eksterne begivenheder.
Sikkerhedsovervejelser
Hooks udføres med de samme tilladelser som Claude Code selv. Dette skaber sikkerhedsimplikationer for multi-bruger miljøer og delte konfigurationer.
Kommando Udførelses Sandbox
Ifølge GitHub-issue #28044 rutes HTTP hooks gennem en sandbox-proxy, der begrænser netværksadgang og filtrerer miljøvariabler. Kommando hooks har ingen sådanne begrænsninger – de kører med fuld shell-adgang.
Dokumentationen anbefaler disse praksisser:
- Gem aldrig legitimationsoplysninger i hook-kommandoer
- Brug miljøvariabler til følsomme data
- Valider alt input fra ${…} udvidelser
- Implementer timeout-grænser for eksterne tjenester
- Brug asynkrone hooks til ikke-kritiske operationer for at undgå blokering ved fejl
Hook Udførelses Isolering
Bruger-niveau hooks i ~/.claude/settings.json gælder for alle projekter. Dette skaber risici, når man arbejder på tværs af forskellige tillidsgrænser. Projektniveau hooks tilsidesætter brugerhooks, men kan ikke helt deaktivere dem.
Menuen /hooks i Claude Code viser alle aktive hooks for den aktuelle session. Gennemgang af denne liste, før du arbejder på følsomme projekter, hjælper med at identificere potentielle sikkerhedsproblemer.
Debugging og Fejlfinding
Hook-fejl vises ikke altid tydeligt i Claude's samtale. Den officielle dokumentation giver flere debugging-tilgange.
Hook Udførelses Logs
Claude Code logger hook-udførelse til sessions debug-output. Ifølge fejlfindingsguiden afslører aktivering af debug-logging:
- Hvilke hooks der matchede for hver begivenhed
- JSON-inputtet sendt til hver hook
- Stdout og stderr output fra hook-processer
- Exit-koder og eksekveringstid
- HTTP-svarkoder og bodies for HTTP hooks
Aktivér debug-logging ved at indstille CLAUDE_DEBUG=1 i miljøet, før du starter Claude Code.
Test Hooks Uafhængigt
Kommando hooks kan testes uden for Claude Code ved manuelt at konstruere JSON-input:
| echo ‘{“event”:”PreToolUse”,”toolName”:”edit_file”,”toolInput”:{“path”:”test.txt”}}’ | ./scripts/my-hook.sh |
Dette validerer hook-logik uden at udløse faktiske Claude-operationer. Exit-koden og stdout/stderr-outputtet skal matche forventet adfærd.
Almindelige Hook Fejl
Community-diskussioner identificerer disse hyppige problemer:
- Timeout-fejl: Standard 10-minutters timeout for kort for langsomme operationer – øg med timeout-feltet
- Fejl i stiudvidelse: Variabler som ${file} er udefinerede for begivenheder, der ikke inkluderer filkontekst
- Tilladelsesfejl: Hook-scripts mangler udførelsestilladelser – kør chmod +x script.sh
- JSON-parsefejl: Dårligt formateret JSON-output fra hooks – valider med jq, før du returnerer
- Miljøvariabel utilgængelighed: Variabler, der ikke er videregivet til hook-processen – tjek Claude Codes miljø
Hook Ydeevne Implikationer
Synkrone hooks blokerer Claude's workflow indtil fuldførelse. Standard timeout på 10 minutter forhindrer uendelige hangs, men selv korte forsinkelser akkumuleres på tværs af flere operationer.
Praktikere rapporterer, at simple valideringshooks har ubetydelig ydeevnepåvirkning. Filformateringshooks forårsager mærkbar, men acceptabel ydeevnepåvirkning. Eksterne API-kald kan skabe friktion i workflowet. Tunge beregningsoperationer drager fordel af asynkron udførelse.
Hook Batching
Flere hooks kan matche den samme begivenhed. Ifølge reference-dokumentationen udføres hooks sekventielt i definitionsrækkefølgen. Hvis en hook blokerer operationen, udføres resterende hooks ikke.
Dette betyder noget for ydeevnen. Fem synkrone hooks på 200 ms hver tilføjer et sekund pr. begivenhed. At kombinere relaterede valideringer i en enkelt hook reducerer overhead.
Avancerede Mønstre
Ud over grundlæggende automatisering muliggør hooks sofistikeret workflow-tilpasning.
Stateful Hook Kæder
Hooks kan bevare tilstand mellem udførelser ved hjælp af filer eller databaser. En PostToolUse hook kan registrere succesfulde operationer, som en PreToolUse hook senere validerer imod:
| #!/bin/bash # Registrer succesfulde redigeringer echo “${toolInput.path}” >> .claude/edit-history.txt |
En ledsagende PreToolUse hook kan tjekke denne historik for at forhindre redundante operationer eller håndhæve ordensbegrænsninger.
Betinget Hook Aktivering
Miljøvariabler styrer hook-adfærd ved kørsel. Indstilling af CLAUDE_SKIP_HOOKS=1 deaktiverer hooks til nødsituationer.
Hooks selv kan tjekke miljøflag:
| #!/bin/bash if [ “$STRICT_MODE” = “1” ]; then # Anvend streng validering exit 1 fi exit 0 |
Dette muliggør udviklingstilstand kontra produktionstilstand adfærd uden konfigurationsændringer.
Multi-Trins Validering
PreToolUse hooks kan implementere multi-niveau validering, hvor exit-kode 2 giver Claude mulighed for at fortsætte med advarsler:
- Hårde fejl (exit 1): Bloker farlige operationer
- Bløde advarsler (exit 2): Advar Claude om at genoverveje
- Bestå med kontekst (exit 0 + JSON): Giv yderligere information
Dette skaber et valideringsspektrum, der er mere nuanceret end binær tillad/afvis.
Integration med CI/CD
Ifølge den officielle platformsintegrationsdokumentation kører Claude Code i CI/CD-miljøer for automatiseret kodegennemgang og problemanalyse. Hooks udvider denne automatisering.
GitHub Actions workflows kan definere hooks, der håndhæver team-politikker under automatiserede sessioner:
| – name: Kør Claude Code med strenge hooks env: STRICT_MODE: 1 run: | claude “Gennemgå denne PR og foreslå forbedringer” |
STRICT_MODE flaget aktiverer betinget valideringslogik i hook-scripts. Dette sikrer, at automatiserede sessioner følger mere stringente regler end interaktiv udvikling.
Generering af Revisionsspor
PostToolUse hooks i CI-miljøer skaber detaljerede revisionslogs over alle Claude-operationer:
| { “event”: “PostToolUse”, “command”: “./scripts/log-to-database.sh”, “async”: true } |
Baggrundslogning påvirker ikke ydeevnen, men giver en komplet driftshistorik til overholdelse og fejlfinding.
Menuen /hooks
Claude Code leverer en /hooks kommando, der viser alle aktive hooks for den aktuelle session. Ifølge den officielle dokumentation viser denne menu:
- Hook begivenhedstype
- Matcher mønstre
- Kommando eller URL endpoint
- Om hooken kører asynkront
- Konfigurationskilde (projekt, bruger eller plugin)
Valg af en hook viser dens komplette konfiguration og tillader midlertidig deaktivering for den aktuelle session.
Deaktiver eller Fjern Hooks
Hooks kan deaktiveres uden at fjerne konfigurationen ved at tilføje "enabled": false til hook-definitionen. Dette bevarer konfigurationen, men forhindrer udførelse.
For permanent at fjerne en hook, slettes dens post fra den relevante settings.json-fil. Ændringer træder i kraft ved næste genstart af sessionen eller når /reload køres.
Hooks i Færdigheder og Agenter
Ifølge den officielle dokumentation gælder hooks defineret inden for færdigheds- eller underagentkonfigurationer kun, når den pågældende færdighed eller agent udføres. Dette muliggør specialiseret automatisering for specifikke workflows.
En debugging underagent kan indeholde hooks, der logger alle værktøjsopkald:
| { “name”: “debugger”, “hooks”: [ { “event”: “PostToolUse”, “command”: “./scripts/log-debug.sh”, “async”: true } ] } |
Disse hooks udløses kun under debugger-agentsessioner, ikke under normal Claude Code-drift.
Referer Scripts efter Sti
Hook-kommandoer understøtter både relative og absolutte stier. Relative stier opløses fra projektets rod, hvor Claude Code kører.
Bedste praksisser fra community-diskussioner:
- Gem hook-scripts i mappen .claude/hooks/
- Brug beskrivende navne: validate-typescript.sh, ikke hook1.sh
- Gør scripts eksekverbare: chmod +x .claude/hooks/*.sh
- Inkluder shebang-linje: #!/usr/bin/env bash eller #!/usr/bin/env python3
- Tilføj fejlhåndtering med set -e i bash-scripts
Fremtidige Hook Kapaciteter
GitHub-anmodninger om funktioner afslører planlagte og anmodede hook-forbedringer:
- Inline script hooks: Definer hook-logik direkte i settings.json uden eksterne filer
- MCP værktøjsintegration: Kald MCP server-værktøjer fra hooks i stedet for shell-kommandoer
- Multi-agent samarbejde: Hooks, der koordinerer mellem Claude-instanser på forskellige maskiner
- Forbedret typing: TypeScript-type-definitioner for hook input/output-skemaer
Ifølge GitHub-issue #4274 sigter anmodningen om integrerede hook-typer (MCP-værktøj, inline-script, API-kald) mod at forenkle konfigurationen og forbedre udvikleroplevelsen.
Ofte Stillede Spørgsmål
Kan hooks forhindre Claude i at udføre farlige kommandoer?
Ja. PreToolUse hooks kan blokere enhver værktøjsudførelse ved at afslutte med kode 1. Dette inkluderer filredigeringer, kommandoeksekvering og MCP værktøjskald. Hooken modtager den komplette værktøjsinput og kan validere mod enhver kriterium, før operationen tillades.
Hvordan debugger jeg en hook, der ikke virker?
Aktivér debug-logging med CLAUDE_DEBUG=1, før du starter Claude Code. Tjek sessionsloggene for hook-udførelsesdetaljer, herunder hvilke hooks der matchede, JSON-inputtet sendt, stdout/stderr output og exit-koder. Test hooks uafhængigt ved at sende sample JSON til hook-scriptet.
Virker hooks med alle Claude Code platforme?
Hooks virker i CLI, desktop-app og VS Code-udvidelse. Ifølge den officielle dokumentation udføres hooks, hvor end Claude Code kører med adgang til filsystemet. Browserbaserede Claude og mobilapps understøtter ikke hooks på grund af sandboxing-begrænsninger.
Kan hooks ændre Claude's svar eller adfærd?
Prompt hooks injicerer instruktioner, der påvirker Claude's adfærd. Agent hooks delegerer begivenhedshåndtering til specialiserede underagenter. Dog kan hooks ikke direkte ændre Claude's genererede tekst eller ræsonnementproces – de fungerer ved at give kontekst og blokere operationer.
Hvad er forskellen mellem asynkrone og synkrone hooks?
Synkrone hooks blokerer Claude's workflow indtil fuldførelse eller timeout. Asynkrone hooks kører i baggrunden uden at blokere. Synkrone hooks kan forhindre operationer via exit-koder. Asynkrone hooks kan ikke blokere, da Claude fortsætter, før hooken er færdig. Brug asynkront til logning og notifikationer, synkront til validering.
Hvordan deler jeg hooks med et team?
Commit filen .claude/settings.json til versionskontrol. Projektniveau hooks gælder for alle teammedlemmer, der kloner repository'et. For organisation-dækkende politikker kan teams vedligeholde en delt bruger-niveau indstillingsfil, som medlemmer kopierer til ~/.claude/settings.json.
Kan HTTP hooks kalde interne API'er bag firewalls?
Ja, hvis Claude Code kører i et miljø med netværksadgang til disse API'er. HTTP hooks foretager standard POST-anmodninger fra maskinen, der kører Claude Code. Virksomhedens firewalls og VPN'er gælder normalt. Sandbox-proxyen nævnt i dokumentationen styrer eksponeringen af miljøvariabler, ikke netværksrouting.
Øger hooks Claude Codes token-forbrug?
Prompt hooks injicerer tekst i Claude's kontekst, hvilket forbruger tokens. Kommando og HTTP hooks påvirker ikke direkte token-forbruget, men deres output (fejlmeddelelser, forslag) bliver en del af samtale-konteksten. Exit-kode 2 med forklarende beskeder tilføjer mere kontekst end exit-kode 1 med simpel blokering.
Konklusion
Claude Code hooks transformerer AI-assistenten fra et kraftfuldt værktøj til en fuldt automatiseret udviklingsplatform. Begivenhedssystemet giver aflytningspunkter gennem Claude's workflow – fra sessionsinitialisering til kontekstkomprimering.
Kommando hooks håndterer lokal validering og formatering. HTTP hooks integrerer eksterne tjenester og databaser. Prompt hooks ændrer adfærd gennem kontekst-injektion. Samlet set muliggør disse automationsmønstre, der håndhæver team-politikker, opretholder kodekvalitet og integrerer med eksisterende udviklingsinfrastruktur.
Matcher-systemet filtrerer hooks til specifikke værktøjer og filmønstre. Exit-koder og JSON-output styrer beslutningsflowet. Asynkron udførelse forhindrer blokering ved langsomme operationer. Det komplette konfigurationsskema understøtter alt fra simpel automatisk formatering til kompleks multi-trins validering.
Start med grundlæggende PostToolUse hooks til kodformatering. Tilføj PreToolUse validering, efterhånden som politikker opstår. Eksperimenter med prompt hooks til adfærdsmodifikation. Byg HTTP-integrationer til team-dækkende håndhævelse.
Tjek den officielle Claude Code-dokumentation for den komplette reference for hooks og opdateret konfigurationsskema, efterhånden som nye funktioner udgives.
