Claude Code Hooks: en praktisk guide till arbetsflödesautomatisering

När du arbetar med Claude Code märker du ett vanligt problem: Den skriver bra kod men glömmer viktiga steg som formatering, att köra tester eller att följa säkerhetsrutiner. Du slutar med att upprepa samma påminnelser om och om igen. Claude Code Hooks låter dig automatisera dessa påminnelser genom att köra shell-kommandon automatiskt vid specifika punkter i ditt arbetsflöde.

I den här handledningen går jag igenom hur du sätter upp hooks för kodformatering, testkörning, aviseringar och filskydd. Du bygger ett automationssystem som upprätthåller dina utvecklingsstandarder utan manuell handpåläggning.

För mer om Claude Code, läs vår guide om bästa praxis för Claude Code och vår handledning om Claude Skills. Vill du lära dig hur du konfigurerar instruktioner på projektnivå? Se vår guide till att skriva en CLAUDE.md.

TL;DR

• Claude Code Hooks är shell-kommandon som körs automatiskt vid särskilda punkter i Claude Codes livscykel (före/efter verktygsanrop, vid sessionsstart, när Claude avslutar)

• Konfigurera dem i .claude/settings.json (projekt) eller ~/.claude/settings.json (globalt) med JSON som anger händelser, matchers och kommandon

• Använd PreToolUse-hooks för att blockera farliga åtgärder innan de sker (exit-kod 2 = blockera)

• Använd PostToolUse-hooks för städuppgifter som formatering, linting eller att köra tester efter att Claude skrivit kod

• Hooks tar emot JSON-kontekst på stdin och kommunicerar resultat via exit-koder, stdout och stderr

Vad är Claude Code Hooks?

Claude Code Hooks är shell-kommandon som körs automatiskt när specifika händelser inträffar under din AI-kodingssession. Tänk på dem som automatiska triggers som kör dina egna skript vid precisa tillfällen—innan Claude skriver en fil, efter att den kört ett kommando eller när den skickar dig en avisering.

Systemet fungerar genom att övervaka Claude Codes åtgärder och matcha dem mot regler du definierar i en konfigurationsfil. När en matchning inträffar körs ditt angivna kommando med tillgång till kontext om vad som just hände. Det ger dig kontroll över Claudes beteende och låter dig automatisera repetitiva uppgifter som annars skulle kräva manuell insats.

Här är en enkel hook som kör en kodformaterare varje gång Claude skriver en Python-fil:

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

Den här hooken har tre delar: 

• Händelsen: PostToolUse (efter att Claude slutfört en åtgärd)

• Matchern: Write (endast vid filskrivning)

• Kommandot: python -m black . (formatera Python-filer i den aktuella katalogen)

Hooken tar emot detaljerad information om vad Claude just gjorde via JSON-data som skickas till skriptets indata, så att du kan bygga mer sofistikerad automation som reagerar på specifika filändringar.

Vill du gå längre med automatisering i Claude Code? Vår handledning om Claude Code Routines visar hur du schemalägger hooks och agenter att köra återkommande i molnet.

Låt oss titta på hur du skapar hooks från grunden och registrerar dem i Claude Code.

Förkunskaper

Du behöver ha några saker på plats innan du börjar:

• Claude Code installerat och igång: Du bör vara bekväm med att använda Claude Code för grundläggande kodningsuppgifter

• Vana vid kommandoraden: Hooks kör shell-kommandon, så du behöver kunna skriva grundläggande terminalkommandon för ditt operativsystem

• Åtkomst till textredigerare: Du kommer att redigera JSON-konfigurationsfiler för att ställa in dina hooks

• Projektkatalog: Ett kodprojekt där du kan testa hooks säkert utan att påverka viktigt arbete

Du behöver inte vara expert på shell-skript, men att förstå hur man kör kommandon som ls, cd och grundläggande filoperationer hjälper dig att följa exemplen. Om du är ny på bash-skript eller terminalen rekommenderar jag vår Introduction to Shell-kurs.

Kom igång med Claude Code Hooks

Nu när du förstår vad hooks är ska vi ställa in din första automation. Processen innebär att välja rätt händelse för ditt behov, konfigurera en enkel regel och testa den med ett grundläggande kommando.

Förstå hook-händelser

Claude Code exponerar mer än 25 hook-händelser. Tabellen nedan täcker de 10 du kommer att använda oftast. För hela listan, se den officiella hook-referensen.

PreToolUse och PostToolUse är de vanligaste händelserna. PreToolUse körs innan Claude utför en åtgärd som att skriva en fil eller köra ett kommando, vilket gör den perfekt för validering eller för att blockera farliga operationer. PostToolUse körs efter att Claude slutfört en åtgärd, vilket fungerar bra för städuppgifter som att formatera kod eller köra tester.

UserPromptSubmit triggas när du skickar en prompt till Claude, innan den behandlar din begäran. Du kan använda detta för att lägga till kontext i din konversation eller validera att prompts uppfyller vissa krav.

Notification körs när Claude skickar dig aviseringar, som när den ber om tillåtelse att köra ett kommando eller när den behöver din input. PermissionRequest triggas när Claude Code visar en behörighetsdialog, så att du kan godkänna eller neka begäran automatiskt å användarens vägnar.

Stop och SubagentStop triggas när Claude är klar med att svara, vilket är användbart för slutliga kontroller eller rapportgenerering. Skillnaden är att Stop utlöses när Claude avslutar sitt övergripande svar, medan SubagentStop gör det när en verktygsskapad hjälpare (en ”underagent”) slutför sitt arbete.

De återstående händelserna, PreCompact, SessionStart och SessionEnd, hanterar livscykelspecifika situationer. PreCompact körs precis innan Claude förkortar konversationshistoriken. ”SessionStart” utlöses i början av en ny session för att sätta upp standarder, och SessionEnd triggas när sessionen stängs, vilket möjliggör städning eller slutrapportering.

Förstå matchers

Matchers är filtren som avgör vilka Claude Code-åtgärder som triggar en hook. Tekniskt är de strängar som tolkas som reguljära uttryck, så du kan använda exakta träffar eller mer flexibla mönster. 

De mest relevanta matchers är enkla som Write (triggas när Claude skriver en fil) eller Edit (triggas vid redigering), samt kombinationer som Edit|Write för att täcka flera åtgärder. 

Du kan också använda prefixmönster som Notebook.* för att matcha alla verktyg som börjar med ”Notebook”. Vill du att hooken ska triggas vid varje åtgärd använder du det universella regexet .*, en tom sträng ("") eller lämnar matcher tomt.

Eftersom matchers är skiftlägeskänsliga och endast verkar på åtgärdsnamn är det bäst att hålla dem så specifika som möjligt. När du behöver finare kontroll (till exempel begränsa hooken till vissa filtyper) kan du läsa JSON-payloaden som Claude skickar in i hooken och tillämpa eget regex eller egna villkor där.

Skapa din första hook i Claude Code

Claude Code erbjuder två sätt att ställa in hooks: via det interaktiva /hooks-kommandot eller genom att direkt redigera konfigurationsfiler. Vi börjar med det interaktiva tillvägagångssättet eftersom det är mer nybörjarvänligt.

Använda kommandot /hooks:

1. Öppna Claude Code och skriv /hooks i chattgränssnittet

2. Välj din triggerhändelse (välj PostToolUse i det här exemplet)

3. Välj "Add new hook" i menyn

4. Ange ditt matchningsmönster (skriv Write för att rikta in dig på filskrivning)

5. Ange ditt kommando:

• Mac: say "Task complete"

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

• Linux: spd-say "Task complete"

6. Spara konfigurationen och gå tillbaka till Claude Code genom att trycka Esc tre gånger

Kommandot /hooks uppdaterar automatiskt din inställningsfil och laddar om konfigurationen. Du kan också använda /hooks när som helst för att visa dina befintliga hooks eller göra ändringar.

Om du föredrar att redigera konfigurationsfiler direkt ligger hooks i ~/.claude/settings.json för globala inställningar, .claude/settings.json i din projektkatalog (committa denna till repot för teamdelade hooks) eller .claude/settings.local.json för personliga hooks som ignoreras av git som standard. För vårt exempel ovan skulle det se ut så här:

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

Efter att du manuellt redigerat filen, starta om Claude Code eller använd kommandot /hooks för att ladda om din konfiguration. Nu hör du en ljudavisering varje gång Claude skriver en fil.

Testa din hook

Innan du går vidare, verifiera att din hook faktiskt fungerar:

1. Be Claude skriva en valfri Python-fil (t.ex. "Skapa en hello.py-fil som skriver ut hello world")

2. Du bör höra ljudaviseringen när Claude slutför skrivåtgärden

3. Om du inte hör något, kontrollera Claude Codes transkript genom att trycka Ctrl-O för att se eventuella felmeddelanden

4. Vanliga problem är att hook-kommandot inte hittas, fel filbehörigheter eller syntaxfel i din konfigurationsfil

Att få detta grundläggande test att fungera sparar dig felsökningstid senare när du bygger mer komplexa hooks. Om du just har redigerat inställningsfilen manuellt, ändrat matcher eller händelse, eller installerat nya verktyg du vill använda i ett hook-kommando, kan det hjälpa att öppna /hooks igen eller starta om Claude för att ladda om konfigurationen.

Detta grundmönster (händelse, matcher, kommando) är grunden för all hook-automation. Du kan bygga vidare på detta genom att lägga till flera kommandon som körs samtidigt när samma händelse triggas. Till exempel kanske du vill både spela upp ett ljud och skapa en backup när Claude skriver en fil. 

Du kan också skapa separata matchers för olika verktyg inom samma händelse, så att filskrivning triggar andra åtgärder än kodredigering. Alla hooks som matchar samma verktygsmönster körs parallellt. Om du konfigurerar flera matchers för samma händelse körs varje hook när dess matcher triggas.

Arbeta med hook-indata

När Claude Code triggar en hook skickar den information om vad som just hände via standardindata (stdin), en dataström som går direkt till ditt kommando när det körs. Denna data är det som gör hooks kraftfulla istället för bara slumpmässiga skript som körs vid godtyckliga tider. 

Claude Code paketerar denna information som JSON och matar den till vilket kommando du än har konfigurerat, oavsett om det är ett enkelt terminalkommando eller ett eget skript.

Anatomi av hook-indata

Varje hook tar emot ett JSON-objekt med grundläggande fält om den aktuella sessionen:

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

Låt oss översätta varje komponent:

• session_id: identifierar din aktuella konversation

• transcript_path: pekar på konversationshistoriken

• cwd: visar arbetskatalogen

• hook_event_name: berättar vilken händelse som utlöstes

Med denna kontext kan dina hooks fatta intelligenta beslut: du kan spåra vilken konversation som triggade en åtgärd, komma åt hela chathistoriken vid behov eller köra kommandon i rätt katalog.

Händelsebaserade indatavariationer

Verktygshändelser som PreToolUse och PostToolUse innehåller extra detaljer om åtgärden, vilket är där hooks blir riktigt användbara för automatisering. I PreToolUse anges tool_input, och tool_response tillkommer i PostToolUse:

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

I hook-indatan visar file_path sökvägen till filen som skrivs eller redigeras, medan content innehåller exakt den text som verktyget är på väg att skriva. Efter körning ekar verktygets svar den slutliga filePath (observera camelCase) för att bekräfta vilken fil som faktiskt berördes, tillsammans med en success-flagga som anger om åtgärden slutfördes korrekt. 

Denna detaljerade information innebär att dina hooks kan reagera olika beroende på vad som faktiskt hände. Du kan till exempel bara formatera Python-filer, bara säkerhetskopiera viktiga kataloger eller bara skicka aviseringar när vissa filtyper ändras.

Händelser som UserPromptSubmit är enklare eftersom de inte involverar verktyg:

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

Observera att UserPromptSubmit-hooks inte använder matchers i sin konfiguration. De triggas på alla prompts, inte verktygsoperationer. Det gör dem perfekta för att logga konversationer, lägga till projektkontext automatiskt eller validera prompts innan Claude behandlar dem.

Läsa hook-indata i praktiken

Låt oss skapa en hook som loggar varje användarprompt. Detta löser problemet med att tappa bort vad du bad Claude göra, särskilt under långa kodningssessioner. Först hook-konfigurationen:

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

Skapa sedan Python-skriptet på ~/.claude/log_prompts.py med följande innehåll:

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

Skriptet läser JSON-datan som Claude Code skickar och loggar prompten med sessionskontext. Detta skapar en sökbar historik över dina interaktioner, vilket blir ovärderligt när du behöver minnas hur du löste ett problem veckor senare.

Arbeta med hook-utdata

Efter att ditt hook-kommando körts behöver det berätta för Claude Code vad som hände och om det ska fortsätta som vanligt. Denna styrmekanism förvandlar hooks från enkla loggningsverktyg till kraftfull arbetsflödesautomatisering som kan styra Claudes beteende. Det sker via tre kanaler: standardutdata (stdout), standardfel (stderr) och exit-koder.

Utdata-kanaler och exit-koder

Standardutdata (stdout) står för normal utdata. Om du till exempel skriver ut något, hamnar det i stdout. För de flesta hooks är det detta som visas i Claude Codes transkript när du trycker Ctrl-O, vilket ger dig en logg över vad din automation gjorde utan att störa huvudkonversationen.

Standardfel (stderr) avser felmeddelanden. Du kan skriva till stderr med 

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

• Kommandorad: echo "message" >&2

Den viktiga skillnaden är att stderr kan skickas direkt till Claude för automatisk hantering, så att den kan svara på problem som dina hooks upptäcker.

Exit-koder berättar för Claude Code vad som ska hända härnäst:

• Exit-kod 0: Lyckades (visar stdout för användaren)

• Exit-kod 2: Blockerande fel (skickar stderr till Claude)

• Andra koder: Icke-blockerande fel (visar stderr för användaren, men fortsätter)

Detta system ger dig finkornig kontroll över när Claude ska stoppa, fortsätta eller få feedback om vad din automation upptäckte. Låt oss titta på exempel för de två viktigaste exit-koderna.

Exit-kod 0: Normal drift

De flesta hooks använder exit-kod 0 för att indikera att allt gick bra. Här är en komplett hook som loggar filåtgärder och meddelar användaren:

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

Den här hooken kör två kommandon: loggar till en fil och skriver sedan ett meddelande i transkriptet. Det finns många sätt att göra detta, men det här tillvägagångssättet är plattformsoberoende och undviker att förlita sig på kommandoradsspecifika detaljer.

Eftersom det inte finns någon explicit exit-kod blir standard 0. Det utskrivna meddelandet visas i Claude Codes transkript och ger dig feedback om att loggningen fungerade. Detta mönster är perfekt för att bygga revisionsspår eller spåra vilka ändringar Claude gör i ditt projekt över tid.

Exit-kod 2: Blockera med feedback

Exit-kod 2 skickar ditt felmeddelande direkt till Claude, så att den kan svara automatiskt. Här blir hooks en säkerhetsmekanism snarare än bara automation. Här är en hook som blockerar farliga filåtgärder:

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

Du behöver skapa säkerhetskontrollskriptet på ~/.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

När den här hooken upptäcker en farlig sökväg avslutas den med kod 2. Claude Code skickar stderr-meddelandet till Claude, som sedan kan förklara för dig varför åtgärden blockerades och föreslå alternativ. Detta förhindrar oavsiktlig skada på systemfiler samtidigt som Claude hålls informerad om dina säkerhetspolicys.

Bygga en smart aviseringshook för Claude Code

Låt oss bygga vår förbättrade aviseringshook som kombinerar indatahantering med smart utdatakontroll. Detta löser brusproblemet från vår ursprungliga hook som aviserade vid varje filändring:

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

Skapa aviseringsskriptet på ~/.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)

Den här hooken läser indata för att förstå vilken fil som ändrades, fattar beslut om aviseringsnivå baserat på filtyp, använder stdout för att logga viktiga ändringar i transkriptet, triggar olika ljudaviseringar beroende på filtyp och avslutar alltid med kod 0 eftersom detta är informativa åtgärder, inte blockerande.

Kombinationen av inputanalys och utdatakontroll skapar en hook som beter sig smart baserat på kontext och ger rätt nivå av feedback både till dig och Claude Code. I stället för irriterande aviseringar för varje temporär fil hör du bara om ändringar som faktiskt är viktiga för ditt projekt.

Observera att detta exempel använder kommandot say, som är tillgängligt på macOS. På Linux kan du använda notify-send, och på Windows ett PowerShell-kommando, för liknande aviseringar.

Vanliga fallgropar med Claude Code Hooks

Några saker som brukar ställa till det under den första veckan med hooks:

echo-rader i shell-profiler bryter hooks. Hooks körs i icke-interaktiva shells som läser in ditt ~/.zshrc eller ~/.bashrc. Om din profil har ovillkorliga echo-rader lägger de text före hookens stdout och bryter JSON-avkodningen. Kapsla in dem i en kontroll för interaktivt shell:

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

Stop-hooks kan loopa för evigt. En Stop-hook som avslutas med kod 2 tvingar Claude att fortsätta arbeta. Om ditt skript inte kontrollerar stop_hook_active från input-JSON och avslutar rent när den är true, snurrar du tills timeout. Inkludera alltid ett tidigt skydd.

Matchers är skiftlägeskänsliga. bash matchar inte Bash. Använd exakt verktygsnamn som det visas i Claude Code.

Utdata begränsas till 10 000 tecken. Om din hook genererar mer trunkeras det innan det injiceras i Claudes kontext. Håll stdout koncis och yta bara det modellen behöver för att agera på.

Förväxling mellan team-nivå och personliga hooks. Hooks i .claude/settings.json delas med teamet (committa dem till repot). För personliga hooks du inte vill dela, använd .claude/settings.local.json, som ignoreras av git som standard.

Hooks vs. skills: när ska vad användas

Hooks och Claude Skills fyller olika syften och fungerar bäst tillsammans. En skill är en markdown-fil som lär Claude hur man gör något (procedurer, konventioner, mallar). En hook är ett shell-kommando som verkställer en regel deterministiskt, oavsett vad Claude beslutar.

Skillnaden är viktig: en skill är ett förslag som modellen kan ignorera under press; en hook avfyras varje gång. Skriv en skill för att dokumentera ditt teams migrationsprocedur. Skriv en PostToolUse-hook för att köra migrations-lintern på varje .sql-fil som Claude skriver. Skillen gör Claude kompetent; hooken gör Claude ansvarstagande.

Avancerade mönster för Claude Code Hooks

Utöver grundläggande aviseringar och loggning kan hooks lösa riktiga problem i utvecklingsarbetsflöden som team möter dagligen. Här är några idéer du kan anpassa för dina egna projekt.

Det fina är att du faktiskt inte behöver bygga dessa hooks manuellt. Du kan helt enkelt ge Claude Code ett av prompt-förslagen nedan, tillsammans med Hooks-referensen i dokumentationen, så genererar den relevant kod och JSON för konfiguration.

Varje mönster kan anpassas för dina specifika verktyg och arbetsflöden. Börja med dem som löser dina största vardagsfrustrationer och utöka din automatisering när du blir bekväm med hook-utveckling.

Avancerade hooks för säkerhet och regelefterlevnad

Hooks är utmärkta för att upprätthålla säkerhetsregler och efterlevnadsstandarder. Här är fyra användningsfall.

API-nyckelskanner

• Problem: Av misstag committa hemligheter till versionskontroll

• Triggers: Före skrivning av någon fil

• Lösning: Skanna filinnehåll efter API-nycklar, tokens och lösenord med regex-mönster

”Skapa ett Python-skript som läser hookens input-JSON, extraherar filinnehållet och använder regex-mönster för att upptäcka vanliga hemliga format som api_key=, token: eller password=.  Vid misstänkt träff, gör lokal verifiering och skicka aldrig råa hemligheter externt. 

Skicka endast maskerade utdrag (t.ex. behåll 4 prefix-/suffixtecken) eller hashvärden till Anthropic-API:et för att analysera misstänkta strängar och avgöra om de är verkliga hemligheter eller variabelnamn. Avsluta med kod 2 och ge Claude feedback om upptäckta hemligheter och säkrare alternativ.”

Licenshuvudtext-kontroll

• Problem: Öppen källkodsprojekt saknar obligatoriska licenstexter i nya filer

• Triggers: Före skrivning av källkodsfiler

• Lösning: Validera att nya .py, .js, .java-filer innehåller korrekt licenstext

”Parsa hook-indatan för att hämta filinnehållet och kontrollera om de första 10 raderna innehåller licenstext med strängmatchning. För mer sofistikerad validering, skicka filhuvudet till Claude via Anthropic-API:t för att verifiera att det innehåller korrekta upphovsrättsnotiser och licensinformation. Blockera filskapande med exit-kod 2 om rubriker saknas och ge Claude rätt licensmall att lägga till.”

Skydd för produktionsfiler

• Problem: Av misstag ändra kritiska systemkonfigurationsfiler

• Triggers: Före redigering av filer i känsliga kataloger

• Lösning: Blockera ändringar i /etc/, nginx.conf, database.yml och andra kritiska konfigurationer

”Extrahera filsökvägen från hookens input-JSON och kontrollera om den matchar mönster som /etc/, production.yml eller andra kritiska filnamn. Använd Claudes API för att analysera filsökvägen och avgöra om det är en konfigurationsfil som kan påverka produktionssystem. Avsluta med kod 2 och ge specifik vägledning om säkrare utvecklingspraxis när farliga sökvägar upptäcks.”

Bildoptimerare

• Problem: Stora bildfiler som saktar ner applikationer och repos

• Triggers: Efter att nya bildfiler lagts till

• Lösning: Komprimera PNG/JPEG-filer med bibehållen visuell kvalitet

”Parsa hook-indatan för att hämta filsökvägen och kontrollera om det är en bildfil med hjälp av filändelsen. Kör komprimeringsverktyg som imageoptim eller anropa TinyPNG-API:t för att komprimera bilden med bibehållen kvalitet. Logga komprimeringsresultaten till stdout så att du kan se hur mycket filstorleken minskade i Claudes transkript.”

Avancerade hooks för versionskontroll-automation

Git-arbetsflöden och dokumentation är områden där hooks också är mycket användbara. Låt oss titta på några idéer.

Git-branchvaliderare

• Problem: Teammedlemmar som av misstag pushar ändringar till skyddade grenar

• Triggers: Före någon filskrivnings- eller redigeringsåtgärd

• Lösning: Kontrollera aktuell Git-branch och blockera åtgärder på main/master/production

”Använd ett enkelt bash-kommando git branch --show-current för att hämta det aktuella branch-namnet och jämför det med en lista över skyddade grenar. Om du är på en skyddad gren, avsluta med kod 2 och skicka ett felmeddelande till Claude som förklarar reglerna för brancheskydd. För komplexa namngivningsregler, använd Claudes API för att analysera branchnamn och avgöra om de matchar skyddsmönster.”

Smart auto-commit

• Problem: Glömma att committa ändringar eller skriva dåliga commit-meddelanden

• Triggers: Efter valfri filändring

• Lösning: Automatisk staging och commit av ändringar med AI-genererade beskrivande meddelanden

”Läs de ändrade filsökvägarna från hook-indatan, kör git diff för att hämta ändringarna och skicka diffen till Claudes API med en prompt som ber om ett koncist commit-meddelande. Använd det genererade meddelandet med kommandona git add och git commit för att automatiskt committa ändringarna. Inkludera filnamn och ändringstyper i API-prompten för att säkerställa att commit-meddelanden följer konventionella standarder.”

Dokumentationsgenerator

• Problem: API-dokumentation som hamnar ur synk med kodändringar

• Triggers: Efter ändringar i gränssnittsfiler (controllers, modeller, API:er)

• Lösning: Köra dokumentationsverktyg som JSDoc, Sphinx eller OpenAPI-generatorer automatiskt

”Kontrollera den ändrade filsökvägen för att avgöra om det är en API-endpoint, modell eller gränssnittfil med hjälp av mönstermatchning. Skicka filinnehållet till Claudes API och be den extrahera API-ändringar och generera dokumentationsuppdateringar. Kör lämpligt dokumentationsverktyg (jsdoc, sphinx-build etc.) och committa den uppdaterade dokumentationen automatiskt.

Avancerade hooks för samarbete och arbetsflödesintegration

Slutligen kan hooks hjälpa till att hålla alla i teamet uppdaterade.

Slack-integration

• Problem: Teamet är inte medvetet om viktiga ändringar i delade kodbaser

• Triggers: När aviseringar skickas för betydande åtgärder

• Lösning: Posta formaterade meddelanden till teamkanaler med filnamn och ändringssammanfattningar

”Extrahera filinformation från hook-indatan och filtrera för viktiga filtyper som källkod eller konfigurationsfiler. Använd Claudes API för att generera en lättläst sammanfattning av vad som ändrats baserat på filnamn och typer. Skicka det formaterade meddelandet till Slack med webhook-URL:er och nämn teammedlemmar vid kritiska ändringar.”

Webhook-dispatcher

• Problem: Manuella CI/CD-triggers som orsakar dröjsmål i distribution

• Triggers: När specifika händelser inträffar (konfigurationsändringar, distributionsfiler ändras)

• Lösning: Anropa externa API:er för att trigga byggen, distributioner eller andra automatiserade processer

”Kontrollera den ändrade filsökvägen mot mönster som Dockerfile, package.json eller distributionskonfigurationer för att avgöra om CI/CD ska triggas. Använd requests-biblioteket i Python för att anropa webhook-URL:er med autentiseringsheaders och payload-data om ändringarna. Inkludera filsökvägar och ändringsmetadata i webhook-payloaden så att externa system kan fatta smarta beslut om vad som ska byggas eller distribueras.”

Statussidor-uppdaterare

• Problem: Kunder är ovetande om underhåll eller distributionsaktiviteter

• Triggers: När distributions- eller infrastrukturfiler ändras

• Lösning: Uppdatera tjänsters statussidor med underhållsaviseringar

”Parsa hook-indata för infrastrukturändringar som Kubernetes-manifester eller Terraform-konfigurationer med hjälp av filsökvägsmönster. Generera underhållsmeddelanden med Claudes API baserat på typen av upptäckta infrastrukturändringar. Publicera statusuppdateringar till tjänster som StatusPage.io eller PagerDuty via deras REST-API:er med lämpliga incidenttyper och uppskattad varaktighet.”

Teamstatus-notifierare

• Problem: Konflikter när flera utvecklare arbetar på samma funktioner ovetandes

• Triggers: När en ny Claude Code-session startas

• Lösning: Att varna teamkanaler om att du påbörjar arbete på ett visst projekt eller komponent

”Läs projektkatalogen från hook-indatan och använd Claudes API för att analysera senaste filer eller git-historik för att förstå vilken typ av arbete som pågår. Skicka ett formaterat meddelande till teamets kommunikationskanaler med ditt namn, projektnamn och fokusområde. Inkludera uppskattad arbetstid och bjud in teammedlemmar att samordna om de arbetar med relaterade funktioner.”

Avslutande tankar

Claude Code Hooks förvandlar oförutsägbara AI-kodassistenter till automatiserade arbetsflöden som körs exakt när du behöver dem. I den här handledningen har du lärt dig hur du ställer in hooks med både det interaktiva kommandot /hooks och manuell konfiguration, förstå JSON-indatan som driver intelligent automatisering och styra Claudes beteende via exit-koder och strukturerade utdata. 

De praktiska mönstren vi gick igenom inkluderar säkerhetsvalidatorer som blockerar farliga åtgärder och smarta aviseringar som minskar brus. Dessa exempel visar hur hooks löser verkliga utvecklingsproblem samtidigt som du får full kontroll över din AI-assistent. Nu när du förstår grunderna kan du bygga automation som matchar ditt teams specifika arbetsflödesbehov. 

Vill du lära dig mer om att arbeta med AI-verktyg? Kolla in DataCamps Understanding Prompt Engineering-kurs, som täcker promptstrategier som fungerar direkt med hook-utveckling. För bredare AI-kodningsfärdigheter, testa vår Intermediate ChatGPT-kurs för att utveckla färdigheter som gör AI-assistenter till mer pålitliga partners i ditt utvecklingsarbetsflöde.