Kort sammendrag: Claude Code-hooks er automatiseringsskript som utføres på spesifikke livssykluspunkt under AI-kodingsøkter, slik at utviklere kan kjøre egendefinerte kommandoer, validere handlinger, formatere kode, sende varsler og håndheve prosjektregler. Disse hookene integreres med Claudes arbeidsflyt gjennom hendelser som SessionStart, PreToolUse og PostToolUse, og støtter kommandobaserte, HTTP-baserte og prompt-baserte utførelsesmønstre med konfigurerbare tidsavbrudd og avslutningskode-atferd.
Claude Codes hook-system forvandler AI-kodingsassistenten fra et hjelpsomt verktøy til et fullstendig automatisert utviklingsmiljø. De fleste utviklere innser ikke omfanget av kontroll som er tilgjengelig gjennom hooks.
Her er poenget – hooks handler ikke bare om å kjøre skript etter filredigeringer. De gir avskjæringspunkter gjennom Claudes hele beslutningsprosess. Før den utfører en kommando. Etter at et verktøy kaller mislykkes. Når den trenger tillatelse. Selv før behandling av brukerprompter.
Denne guiden dekker alt det offisielle dokumentasjonen gir, pluss praktiske mønstre som fellesskapsdiskusjoner avslører faktisk fungerer i produksjonsmiljøer.
Hva Claude Code Hooks Faktisk Gjør
I henhold til den offisielle Claude Code-dokumentasjonen er hooks brukerdefinerte skallkommandoer, HTTP-endepunkter eller prompt-injeksjoner som utføres på spesifikke punkter i Claude Codes livssyklus. De mottar strukturert JSON-input via stdin og kontrollerer arbeidsflyten gjennom avslutningskoder eller HTTP-responser.
Automatiseringen går dypere enn de fleste guider antyder. Hooks kan blokkere verktøyutførelse helt, injisere ytterligere kontekst i Claudes resonnement, utløse eksterne tjenester og håndheve valideringsregler som Claude må respektere.
Tre kjernetyper av hooks finnes:
- Kommando-hooks: Skallskript som kommuniserer via stdout, stderr og avslutningskoder
- HTTP-hooks: Eksterne endepunkter som mottar POST-forespørsler og returnerer JSON-responser
- Prompt-hooks: Dynamiske instruksjoner injisert i Claudes kontekst på spesifikke hendelser
Hver type tjener forskjellige automatiseringsmønstre. Kommando-hooks håndterer lokal validering og formatering. HTTP-hooks integreres med eksterne tjenester og databaser. Prompt-hooks modifiserer Claudes atferd uten eksterne prosesser.
Hook Livssyklus og Hendelsessystem
Den offisielle dokumentasjonen definerer flere hook-hendelser (SessionStart, UserPromptSubmit, PreToolUse, PermissionRequest, PostToolUse, PostToolUseFailure, Notification, og andre) som utløses under Claude Codes utførelsesflyt. Å forstå når hver enkelt utløses bestemmer hvilken automatisering som blir mulig.
| Hendelse | Når den utløses | Kan blokkere |
|---|---|---|
| SessionStart | Når en økt begynner eller gjenopptas | Nei |
| UserPromptSubmit | Når du sender en prompt, før Claude behandler den | Ja |
| PreToolUse | Før et verktøykall utføres | Ja |
| PermissionRequest | Når en tillatelsesdialog vises | Ja |
| PostToolUse | Etter at et verktøykall lykkes | Nei |
| PostToolUseFailure | Etter at et verktøykall mislykkes | Nei |
| Notification | Når Claude Code sender et varsel | Nei |
| SubmitMessage | Når Claude sender en melding til brukeren | Nei |
| ContextCompaction | Når kontekstvinduet nærmer seg grenser | Nei |
Blokkeringsmuligheten er viktigst. PreToolUse hooks kan forhindre farlige operasjoner før de utføres. Avslutningskode 1 blokkerer handlingen. Avslutningskode 0 tillater den. Avslutningskode 2 ber Claude om å revurdere.
Men vent. PostToolUse hooks kan ikke angre handlinger siden verktøyet allerede er utført. Denne begrensningen former hvordan valideringslogikken struktureres. Kritiske kontroller hører hjemme i PreToolUse. Opprydding og formatering hører hjemme i PostToolUse.
Utforsk AI-verktøy-fordeler mens du setter opp Claude Code
Hvis du jobber med Claude Code-hooks, velger du kanskje også andre AI-verktøy rundt arbeidsflyten din. Get AI Perks samler oppstarts-kreditter og rabatter på programvare for AI- og skyverktøy på ett sted. Plattformen inkluderer over 200 tilbud, med fordelsbetingelser og kravveiledning for hver enkelt.
Leter du etter fordeler med Claude eller andre AI-verktøy?
Sjekk Get AI Perks for å:
- bla gjennom tilbud for Claude og andre AI-verktøy
- sammenligne fordelsbetingelser før du søker
- finne oppstartsrabatter på tvers av verktøystakken din
👉 Besøk Get AI Perks for å utforske gjeldende programvarefordeler for AI.
Konfigurasjon og Filstruktur
Hooks defineres i filen .claude/settings.json innenfor et prosjekt. Konfigurasjonsskjemaet støtter globale hooks og verktøyspesifikke matchere som filtrerer når hooks utføres.
Grunnleggende kommando-hook-struktur:
| { “hooks”: [ { “event”: “PostToolUse”, “command”: “prettier –write”, “args”: [“${file}”] } ] } |
Variabelen ${file} utvides til den faktiske filstien fra verktøyets input. Ifølge den offisielle dokumentasjonen støtter hooks slike variabelutvidelser i kommandofelt og argumentfelt.
Hook Plasseringshierarki
Claude Code sjekker flere steder for hook-definisjoner, med en klar prioritetsrekkefølge:
- Prosjektnivå: .claude/settings.json i det gjeldende arbeidsområdet
- Bruker-nivå: ~/.claude/settings.json for alle økter
- Plugin-levert: Hooks bundlet med installerte plugins
Prosjekthooks overstyrer brukerhooks for samme hendelse. Dette tillater prosjektspesifikke formateringsregler, samtidig som globale varslingshåndterere opprettholdes.
Matcher-mønstre for selektiv utførelse
Matcher-systemet filtrerer hooks til spesifikke verktøy eller betingelser. Uten matchere utløses hooks for hver forekomst av hendelsen deres.
| { “hooks”: [ { “event”: “PreToolUse”, “matcher”: { “toolName”: “edit_file”, “pathPattern”: “src/**/*.ts” }, “command”: “./scripts/validate-typescript.sh” } ] } |
Feltet pathPattern aksepterer glob-syntaks. Feltet toolName matcher mot Claudes innebygde verktøy som edit_file, execute_command, read_file og create_directory.
Fellesskapsdiskusjoner avslører at kombinasjoner av matchere fungerer med OG-logikk. Alle angitte matchere må stemme for at hooken skal utføres.
Kommando-hooks: Integrasjon med skallskript
Kommando-hooks utfører skallkommandoer eller skript med strukturert JSON-input. De representerer den vanligste hook-typen for lokal automatisering.
Den offisielle dokumentasjonen spesifiserer at kommando-hooks mottar JSON via stdin med denne strukturen:
| { “event”: “PreToolUse”, “toolName”: “edit_file”, “toolInput”: { “path”: “src/app.ts”, “content”: “…” }, “sessionId”: “abc123”, “turnId”: “turn-456” }Skript analyserer denne inputen for å ta beslutninger. En Python-valideringshook kan se slik ut:#!/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) |
Avslutningskode 0 tillater operasjonen. Avslutningskode 1 blokkerer den og viser stderr-meldingen til Claude. Avslutningskode 2 utløser spesiell atferd avhengig av hendelsen.
Avslutningskode 2-atferd
I henhold til den offisielle dokumentasjonen for hooks, har avslutningskode 2 hendelsesspesifikk betydning (PreToolUse: blokkerer og ber om revurdering; UserPromptSubmit: gir kontekst uten å blokkere; PermissionRequest: blokkerer tillatelse):
- PreToolUse: Blokkere verktøyet og ber Claude om å revurdere med stderr-meldingen som kontekst
- UserPromptSubmit: Gir stderr-utdataen som tilleggskontekst uten å blokkere
- PermissionRequest: Blokkerer tillatelsesgodkjenningen
Dette skaper en mellomting mellom hard blokkering og tillatelse. Claude mottar tilbakemelding om hvorfor handlingen kan være problematisk og kan justere sin tilnærming.
Asynkrone Kommando-hooks
Flagget async: true kjører hooks i bakgrunnen uten å blokkere Claudes arbeidsflyt. Dette er viktig for langsomme operasjoner som utsendelse av varsler eller metrikksamling.
| { “event”: “PostToolUse”, “matcher”: { “toolName”: “execute_command” }, “command”: “./scripts/log-to-analytics.sh”, “async”: true, “timeout”: 30 } |
Når en asynkron hook utløses, starter Claude Code prosessen og fortsetter umiddelbart. Timeout-feltet setter maksimal utførelsestid i sekunder. Hvis det ikke er spesifisert, bruker asynkrone hooks en standard tidsavbrudd på 10 minutter.
Realtale: Asynkrone hooks kan ikke blokkere operasjoner siden de kjører etter at Claude fortsetter. De fungerer for logging, varslinger og opprydding – ikke validering.
HTTP-hooks: Integrasjon med eksterne tjenester
HTTP-hooks sender JSON-nyttelaster til eksterne endepunkter og analyserer responser for beslutningskontroll. De muliggjør integrasjon med valideringstjenester, databaser og tredjepartsverktøy.
Grunnleggende HTTP-hook-konfigurasjon:
| { “event”: “PreToolUse”, “url”: “api.example.com/validate”, “headers”: { “Authorization”: “Bearer ${API_TOKEN}” }, “timeout”: 5 } |
Nyttelaststrukturen samsvarer med kommando-hook-input, men mottas som HTTP POST-kropp. Responsen bestemmer Claudes neste handling.
HTTP Respons-håndtering
I henhold til den offisielle dokumentasjonen tolker HTTP-hooks responser basert på statuskode og kroppsinnhold:
| Statuskode | Effekt | Meldingskilde |
|---|---|---|
| 200 | Tillater operasjon | Responskropp (valgfritt) |
| 400 | Blokkerer operasjon | Responskropp vist for Claude |
| 500 | Hook-feil, tillater operasjon | Logget, men ikke vist for Claude |
| Annen | Tillater operasjon | Hook-feil blokkerer ikke arbeidsflyten |
Responskroppen kan inkludere et meldingsfelt som Claude ser som kontekst. Dette gjør det mulig for valideringstjenester å forklare hvorfor en operasjon ble blokkert.
Miljøvariabel-interpolering
HTTP-hooks støtter ${VAR}-syntaks i url, headers og andre strengfelter. Variabler utvides fra miljøet der Claude Code kjører.
I henhold til den offisielle MCP-dokumentasjonen inkluderer miljøvariabelutvidelse en standard standardfall-syntaks: ${VAR:-default} utvides til VAR hvis satt, ellers brukes standardverdien.
Sikkerhetsbegrensning: I henhold til GitHub-utgave #28044 kan HTTP-hooks bare få tilgang til miljøvariabler som eksplisitt er oppført i feltet allowedEnvVars i konfigurasjonen. Dette forhindrer utilsiktet eksponering av legitimasjon.
Prompt-hooks: Kontekstinnsprøytning
Prompt-hooks setter inn dynamiske instruksjoner i Claudes kontekst ved spesifikke hendelser. De modifiserer atferd uten eksterne prosesser eller API-kall.
| { “event”: “SessionStart”, “prompt”: “Du jobber med et TypeScript-prosjekt. Bruk alltid strenge null-sjekker og foretrekk async/await fremfor promises.” } |
Den innsatte teksten blir en del av Claudes systeminstruksjoner for den økten. Prompt-hooks kan også bruke malvariabler som utvides basert på hendelsesdata.
Dynamisk promptgenerering
I henhold til den offisielle dokumentasjonen støtter prompt-hooks kommandofelt som genererer dynamiske prompter:
| { “event”: “ContextCompaction”, “type”: “prompt”, “command”: “./scripts/generate-context-summary.sh” } |
Kommandoen mottar standard JSON-input via stdin og sender promptteksten til stdout. Dette muliggjør kontekstbevisst instruksjonsgenerering basert på prosjektstatus.
Agent-baserte Hooks
Agent-hooks spesifiserer en underagent som håndterer hendelsen i stedet for direkte prompt-innsprøytning. Underagenten mottar kontekst om hendelsen og kan utføre resonnement i flere trinn.
| { “event”: “PostToolUseFailure”, “agent”: “debugger”, “agentPrompt”: “Et verktøykall mislyktes. Analyser feilen og foreslå rettinger.” } |
Den navngitte underagenten må defineres i prosjektkonfigurasjonen. Agent-hooks muliggjør kompleks beslutningslogikk som enkel prompt-innsprøytning ikke kan gi.
Praktiske Hook-mønstre
Fellesskapsdiskusjoner og offisielle eksempler avslører spesifikke automatiseringsmønstre som fungerer pålitelig i produksjon.
Automatisk formatering av kode etter redigeringer
Det vanligste mønsteret formaterer kode automatisk etter at Claude har redigert filer:
| { “event”: “PostToolUse”, “matcher”: { “toolName”: “edit_file”, “pathPattern”: “**/*.{js,ts,jsx,tsx}” }, “command”: “prettier”, “args”: [“–write”, “${toolInput.path}”] } |
Variabelen ${toolInput.path} utvides til den redigerte filstien. PostToolUse sikrer at formatering skjer etter vellykkede redigeringer, men blokkerer ikke Claudes arbeidsflyt.
Blokker modifikasjoner av beskyttede filer
PreToolUse hooks håndhever regler for filbeskyttelse:
| { “event”: “PreToolUse”, “matcher”: { “toolName”: “edit_file” }, “command”: “./scripts/check-protected.sh” } |
Skriptet validerer målbanen mot beskyttede mønstre og avsluttes med kode 1 for å blokkere forbudte redigeringer.
Få varsler når Claude trenger input
I henhold til den offisielle arbeidsflytguiden kan Notification-hooks utløse skrivebordsvarsler eller sende meldinger til eksterne tjenester:
| { “event”: “Notification”, “command”: “osascript”, “args”: [“-e”, “display notification \”${message}\” with title \”Claude Code\””] } |
Dette utløses når Claude Code sender et varsel, inkludert når den venter på brukerinput eller etter at en oppgave er fullført.
Re-injiser kontekst etter komprimering
ContextCompaction-hooks gjenoppretter viktig kontekst når samtalvinduet fylles opp:
| { “event”: “ContextCompaction”, “type”: “prompt”, “command”: “cat .claude/critical-context.md” } |
Kommandooutputen settes inn igjen i Claudes kontekst etter at komprimering har fjernet eldre meldinger. Dette forhindrer tap av kritiske prosjektspesifikke instruksjoner.
Revisjonslogging av konfigurasjonsendringer
Spor når Claude endrer konfigurasjonsfiler:
| { “event”: “PostToolUse”, “matcher”: { “toolName”: “edit_file”, “pathPattern”: “**/{package.json,.env,*.config.*}” }, “command”: “git”, “args”: [“add”, “${toolInput.path}”], “async”: true } |
Asynkron utførelse forhindrer blokkering av Claude mens git-operasjoner fullføres. Dette skaper en revisjonslogg over konfigurasjonsendringer uten manuell staging.
JSON-utdata og beslutningskontroll
Kommando-hooks kan produsere strukturert JSON for å gi detaljert tilbakemelding utover enkle avslutningskoder. I henhold til den offisielle referansen, muliggjør JSON-utdata flerfeltresponser som Claude tolker for beslutningstaking.
| { “allowed”: false, “message”: “Denne filen er beskyttet av teamets retningslinjer”, “suggestion”: “Opprett en ny fil i src/features/ i stedet” } |
Feltet allowed kontrollerer om operasjonen fortsetter. Meldingen vises for Claude som kontekst. Feltet suggestion gir alternative tilnærminger.
For at hooks skal produsere JSON, må de:
- Skrive gyldig JSON til stdout
- Avslutte med kode 0 (for tillatt) eller 1 (for blokkert)
- Inkludere minst det boolske feltet allowed
Claude Code analyserer JSON-en og bruker den til å forbedre tilbakemeldingssløyfen. Avslutningskoder bestemmer fortsatt den primære beslutningen, men JSON gir rikere kontekst.
Referanse for Hook Input-felt
Alle hooks mottar et JSON-objekt via stdin med vanlige felt pluss hendelsesspesifikke data. Å forstå det komplette skjemaet muliggjør mer sofistikert hook-logikk.
Vanlige input-felt
Alle hooks mottar disse grunnleggende feltene:
- event: Navnet på hook-hendelsen (f.eks. “PreToolUse”)
- sessionId: Unik identifikator for den gjeldende Claude-økten
- turnId: Identifikator for den gjeldende samtalrunden
- timestamp: ISO 8601 tidsstempel for når hendelsen utløste
Verktøy-hendelsesfelt
PreToolUse, PostToolUse og PostToolUseFailure hendelser inkluderer:
- toolName: Navn på verktøyet som blir kalt (edit_file, execute_command, etc.)
- toolInput: Objekt som inneholder verktøyets input-parametere
- toolResponse: Verktøyets utdata (kun PostToolUse)
- error: Feildetaljer, inkludert melding og kode (kun PostToolUseFailure)
ToolInput-strukturen varierer med verktøyet. For edit_file inneholder den path og content. For execute_command inneholder den command og args.
Tillatelses-hendelsesfelt
PermissionRequest-hendelser inkluderer:
- permissionType: Type tillatelse som er forespurt (file_write, command_execute, etc.)
- requestedAction: Spesifikk handling som krever tillatelse
- resourcePath: Filsti eller ressursidentifikator som påvirkes
MCP Verktøy-hooks
I henhold til den offisielle hook-referansen kan hooks matche mot Model Context Protocol (MCP) verktøy ved hjelp av mcpTool-matcherfeltet. Dette muliggjør hook-utførelse når Claude bruker eksterne verktøy levert av MCP-servere.
| { “event”: “PreToolUse”, “matcher”: { “mcpTool”: “database/query” }, “command”: “./scripts/validate-sql.sh” } |
Verdien mcpTool matcher mot verktøynavnet i formatet servernavn/verktøynavn. Dette muliggjør valideringslogikk for databaseforespørsler, API-kall eller andre eksterne operasjoner.
GitHub-funksjonsforespørsler indikerer økende interesse for dypere MCP-integrasjon, inkludert hooks som kan inspisere MCP-servervarsler og respondere på eksterne hendelser.
Sikkerhetshensyn
Hooks utføres med samme rettigheter som Claude Code selv. Dette skaper sikkerhetsimplikasjoner for miljøer med flere brukere og delte konfigurasjoner.
Kommandoutførelses-sandbox
I henhold til GitHub-utgave #28044, rutes HTTP-hooks gjennom en sandkasse-proxy som begrenser nettverkstilgang og filtrerer miljøvariabler. Kommando-hooks har ingen slike restriksjoner – de kjører med full skalltilgang.
Dokumentasjonen anbefaler følgende praksis:
- Aldri lagre legitimasjon i hook-kommandoer
- Bruk miljøvariabler for sensitive data
- Valider all input fra ${…} utvidelser
- Implementer tidsavbruddsgrenser for eksterne tjenester
- Bruk asynkrone hooks for ikke-kritiske operasjoner for å forhindre blokkering ved feil
Hook Utførelsesisolasjon
Bruker-nivå hooks i ~/.claude/settings.json gjelder for alle prosjekter. Dette skaper risiko når man arbeider på tvers av forskjellige tillitsgrenser. Prosjekt-nivå hooks overstyrer bruker-hooks, men kan ikke helt deaktivere dem.
/hooks-menyen i Claude Code viser alle aktive hooks for gjeldende økt. Gjennomgang av denne listen før arbeid på sensitive prosjekter hjelper med å identifisere potensielle sikkerhetsbekymringer.
Feilsøking og Problemløsning
Hook-feil dukker ikke alltid klart opp i Claudes samtale. Den offisielle dokumentasjonen gir flere feilsøkingsmetoder.
Hook Utførelseslogger
Claude Code logger hook-utførelse til øktens feilsøkingsutdata. I henhold til feilsøkingsguiden, avslører aktivering av feilsøkingslogging:
- Hvilke hooks som matchet for hver hendelse
- JSON-inputen som ble sendt til hver hook
- Stdout- og stderr-utdata fra hook-prosesser
- Avslutningskoder og utførelsestid
- HTTP-respons koder og kropper for HTTP-hooks
Aktiver feilsøkingslogging ved å sette CLAUDE_DEBUG=1 i miljøet før du starter Claude Code.
Testing av Hooks Uavhengig
Kommando-hooks kan testes utenfor Claude Code ved manuelt å konstruere JSON-input:
| echo ‘{“event”:”PreToolUse”,”toolName”:”edit_file”,”toolInput”:{“path”:”test.txt”}}’ | ./scripts/my-hook.sh |
Dette validerer hook-logikken uten å utløse faktiske Claude-operasjoner. Avslutningskoden og stdout/stderr-utdataen bør samsvare med forventet atferd.
Vanlige Hook-feil
Fellesskapsdiskusjoner identifiserer disse hyppige problemene:
- Tidsavbruddsfeil: Standard 10-minutters tidsavbrudd for kort for langsomme operasjoner – øk med timeout-feltet
- Feil ved baneutvidelse: Variabler som ${file} er ikke definert for hendelser som ikke inkluderer filkontekst
- Tillatelsesfeil: Hook-skript mangler utførelsestillatelser – kjør chmod +x script.sh
- JSON-analysefeil: Feilaktig JSON-utdata fra hooks – valider med jq før du returnerer
- Miljøvariabel utilgjengelighet: Variabler er ikke propagert til hook-prosessen – sjekk Claude Codes miljø
Hook Ytelsesimplikasjoner
Synkrone hooks blokkerer Claudes arbeidsflyt til fullføring. Standard tidsavbruddet på 10 minutter forhindrer uendelige heng, men selv korte forsinkelser akkumuleres over flere operasjoner.
Praktikere rapporterer at enkle valideringshooks har ubetydelig ytelsespåvirkning. Filformateringshooks forårsaker merkbar, men akseptabel ytelsespåvirkning. Eksterne API-kall kan skape friksjon i arbeidsflyten. Tunge beregningsoperasjoner drar nytte av asynkron utførelse.
Hook Batching
Flere hooks kan matche samme hendelse. I henhold til referansedokumentasjonen, utføres hooks sekvensielt i definisjonsrekkefølge. Hvis en hook blokkerer operasjonen, utføres ikke de resterende hooks.
Dette er viktig for ytelse. Fem synkrone hooks på 200ms hver legger til ett sekund per hendelse. Kombinering av relaterte valideringer til en enkelt hook reduserer overhead.
Avanserte Mønstre
Utover grunnleggende automatisering muliggjør hooks sofistikert arbeidsflyt-tilpasning.
Tilstandsbaserte Hook-kjeder
Hooks kan opprettholde tilstand mellom utførelser ved hjelp av filer eller databaser. En PostToolUse hook kan registrere vellykkede operasjoner som en PreToolUse hook senere validerer mot:
| #!/bin/bash # Record successful edits echo “${toolInput.path}” >> .claude/edit-history.txt |
En medfølgende PreToolUse hook kan sjekke denne historikken for å forhindre redundante operasjoner eller håndheve ordensbegrensninger.
Betinget Hook Aktivering
Miljøvariabler kontrollerer hook-atferd ved kjøretid. Innstilling av CLAUDE_SKIP_HOOKS=1 deaktiverer hooks for nødsituasjoner.
Hooks selv kan sjekke miljøflagg:
| #!/bin/bash if [ “$STRICT_MODE” = “1” ]; then # Apply strict validation exit 1 fi exit 0 |
Dette muliggjør utviklingsmodus versus produksjonsmodus-atferd uten konfigurasjonsendringer.
Flertrinns Validering
PreToolUse hooks kan implementere flertrinns validering der avslutningskode 2 lar Claude fortsette med advarsler:
- Hard feil (avslutning 1): Blokker farlige operasjoner
- Myke advarsler (avslutning 2): Varsle Claude om å revurdere
- Bestått med kontekst (avslutning 0 + JSON): Gi ytterligere informasjon
Dette skaper et valideringsspekter som er mer nyansert enn binær tillat/nekt.
Integrasjon med CI/CD
I henhold til den offisielle dokumentasjonen for plattformintegrasjon, kjører Claude Code i CI/CD-miljøer for automatisert kodegjennomgang og feilsøking. Hooks utvider denne automatiseringen.
GitHub Actions-arbeidsflyter kan definere hooks som håndhever teamretningslinjer under automatiserte økter:
| – name: Run Claude Code with strict hooks env: STRICT_MODE: 1 run: | claude “Review this PR and suggest improvements” |
STRICT_MODE-flagget aktiverer betinget valideringslogikk i hook-skript. Dette sikrer at automatiserte økter følger strengere regler enn interaktiv utvikling.
Generering av revisjonslogg
PostToolUse hooks i CI-miljøer oppretter detaljerte revisjonslogger over alle Claude-operasjoner:
| { “event”: “PostToolUse”, “command”: “./scripts/log-to-database.sh”, “async”: true } |
Bakgrunnslogging påvirker ikke ytelsen, men gir en fullstendig operasjonshistorikk for overholdelse og feilsøking.
Menyen /hooks
Claude Code tilbyr en /hooks kommando som viser alle aktive hooks for gjeldende økt. I henhold til den offisielle dokumentasjonen viser denne menyen:
- Hook hendelsestype
- Matcher-mønstre
- Kommando eller URL-endepunkt
- Om hooken kjører asynkront
- Konfigurasjonskilde (prosjekt, bruker eller plugin)
Valg av en hook viser dens komplette konfigurasjon og tillater midlertidig deaktivering for gjeldende økt.
Deaktiver eller fjern Hooks
Hooks kan deaktiveres uten å fjerne konfigurasjonen ved å legge til “enabled”: false i hook-definisjonen. Dette bevarer konfigurasjonen, men forhindrer utførelse.
For å permanent fjerne en hook, slett dens oppføring fra den aktuelle settings.json-filen. Endringer trer i kraft ved neste omstart av økten eller når du kjører /reload.
Hooks i Ferdigheter og Agenter
I henhold til den offisielle dokumentasjonen, gjelder hooks definert innenfor ferdighets- eller underagent-konfigurasjoner kun når den ferdigheten eller agenten utføres. Dette muliggjør spesialisert automatisering for spesifikke arbeidsflyter.
En feilsøkingsunderagent kan inkludere hooks som logger alle verktøykall:
| { “name”: “debugger”, “hooks”: [ { “event”: “PostToolUse”, “command”: “./scripts/log-debug.sh”, “async”: true } ] } |
Disse hooksene utløses kun under debugger-agentøkter, ikke under normal Claude Code-drift.
Referanse av Skript etter Bane
Hook-kommandoer støtter både relative og absolutte baner. Relative baner løses fra prosjektets rot der Claude Code kjører.
Beste praksis fra fellesskapsdiskusjoner:
- Lagre hook-skript i .claude/hooks/-katalogen
- Bruk beskrivende navn: validate-typescript.sh ikke hook1.sh
- Gjør skript utførbare: chmod +x .claude/hooks/*.sh
- Inkluder shebang-linje: #!/usr/bin/env bash eller #!/usr/bin/env python3
- Legg til feilhåndtering med set -e i bash-skript
Fremtidige Hook-kapasiteter
GitHub-funksjonsforespørsler avslører planlagte og forespurte hook-forbedringer:
- Inline skript-hooks: Definer hook-logikk direkte i settings.json uten eksterne filer
- MCP verktøyintegrasjon: Kall MCP-serververktøy fra hooks i stedet for skallkommandoer
- Samarbeid mellom flere agenter: Hooks som koordinerer mellom Claude-instanser på forskjellige maskiner
- Forbedret typing: TypeScript type-definisjoner for hook input/output-skjemaer
I henhold til GitHub-utgave #4274, tar forespørselen om integrerte hook-typer (MCP-verktøy, inline-skript, API-kall) sikte på å forenkle konfigurasjon og forbedre utvikleropplevelsen.
Ofte Stilte Spørsmål
Kan hooks forhindre Claude i å utføre farlige kommandoer?
Ja. PreToolUse hooks kan blokkere enhver verktøyutførelse ved å avslutte med kode 1. Dette inkluderer filredigeringer, kommandoutførelse og MCP-verktøykall. Hooken mottar den komplette verktøyinputen og kan validere mot ethvert kriterium før den tillater operasjonen.
Hvordan feilsøker jeg en hook som ikke fungerer?
Aktiver feilsøkingslogging med CLAUDE_DEBUG=1 før du starter Claude Code. Sjekk øktloggene for detaljer om hook-utførelse, inkludert hvilke hooks som matchet, JSON-inputen som ble sendt, stdout/stderr-utdata og avslutningskoder. Test hooks uavhengig ved å sende eksempel-JSON til hook-skriptet.
Fungerer hooks med alle Claude Code-plattformer?
Hooks fungerer i CLI, desktop-appen og VS Code-utvidelsen. I henhold til den offisielle dokumentasjonen, utføres hooks der Claude Code kjører med tilgang til filsystemet. Nettleserbaserte Claude og mobilapper støtter ikke hooks på grunn av sandboxing-begrensninger.
Kan hooks endre Claudes responser eller atferd?
Prompt hooks setter inn instruksjoner som påvirker Claudes atferd. Agent hooks delegerer hendelseshåndtering til spesialiserte underagenter. Hooks kan imidlertid ikke direkte endre Claudes genererte tekst eller resonnement – de fungerer ved å gi kontekst og blokkere operasjoner.
Hva er forskjellen mellom asynkrone og synkrone hooks?
Synkrone hooks blokkerer Claudes arbeidsflyt til fullføring eller tidsavbrudd. Asynkrone hooks kjører i bakgrunnen uten å blokkere. Synkrone hooks kan forhindre operasjoner gjennom avslutningskoder. Asynkrone hooks kan ikke blokkere siden Claude fortsetter før hooken er fullført. Bruk asynkron for logging og varslinger, synkron for validering.
Hvordan deler jeg hooks på tvers av et team?
Commit filen .claude/settings.json til versjonskontroll. Prosjekt-nivå hooks gjelder for alle teammedlemmer som kloner depotet. For organisasjonsomfattende retningslinjer kan team vedlikeholde en delt bruker-nivå innstillingsfil som medlemmene kopierer til ~/.claude/settings.json.
Kan HTTP hooks kalle interne API-er bak brannmurer?
Ja, hvis Claude Code kjører i et miljø med nettverkstilgang til disse API-ene. HTTP hooks lager standard POST-forespørsler fra maskinen som kjører Claude Code. Bedriftsbrannmurer og VPN-er gjelder normalt. Sandkasse-proxyen nevnt i dokumentasjonen kontrollerer eksponering av miljøvariabler, ikke nettverksruting.
Øker hooks Claude Codes token-bruk?
Prompt hooks setter inn tekst i Claudes kontekst, noe som forbruker tokens. Kommando- og HTTP-hooks påvirker ikke tokenbruken direkte, men deres utdata (feilmeldinger, forslag) blir en del av samtale konseptet. Avslutningskode 2 med forklarende meldinger legger til mer kontekst enn avslutningskode 1 med enkel blokkering.
Konklusjon
Claude Code hooks forvandler AI-assistenten fra et kraftig verktøy til en fullstendig automatisert utviklingsplattform. Hendelsessystemet gir avskjæringspunkter gjennom Claude sin arbeidsflyt – fra øktinitialisering til kontekstkomprimering.
Kommando-hooks håndterer lokal validering og formatering. HTTP-hooks integrerer eksterne tjenester og databaser. Prompt-hooks modifiserer atferd gjennom kontekstinnsprøytning. Sammen muliggjør disse automatiseringsmønstre som håndhever teamretningslinjer, opprettholder kodingskvalitet og integreres med eksisterende utviklingsinfrastruktur.
Matcher-systemet filtrerer hooks til spesifikke verktøy og filmønstre. Avslutningskoder og JSON-utdata kontrollerer beslutningsflyten. Asynkron utførelse forhindrer blokkering på langsomme operasjoner. Det komplette konfigurasjonsskjemaet støtter alt fra enkel autoformatering til kompleks flertrinns validering.
Start med grunnleggende PostToolUse hooks for kodeformatering. Legg til PreToolUse validering etter hvert som retningslinjer oppstår. Eksperimenter med prompt hooks for atferdsmodifikasjon. Bygg HTTP-integrasjoner for teamomfattende håndhevelse.
Sjekk den offisielle Claude Code-dokumentasjonen for den komplette hook-referansen og oppdatert konfigurasjonsskjema etter hvert som nye funksjoner slippes.
