Claude Code Hooks: Ein praktischer Leitfaden zur Automatisierung von Arbeitsabläufen

Bei der Arbeit mit Claude Code, wirst du ein häufiges Problem bemerken: Es schreibt guten Code, vergisst aber wichtige Schritte wie Formatierung, Testläufe oder das Befolgen von Sicherheitsprotokollen. Am Ende wiederholst du immer wieder dieselben Erinnerungen. 

Mit Claude Code Hooks kannst du diese Erinnerungen automatisieren, indem du Shell-Befehle automatisch an bestimmten Punkten in deinem Arbeitsablauf ausführst.

Dieses Tutorial zeigt dir, wie du Hooks für die Codeformatierung, Testausführung, Benachrichtigungen und den Dateischutz einrichtest. Du wirst ein Automatisierungssystem aufbauen, das deine Entwicklungsstandards konsequent durchsetzt, ohne dass du manuell eingreifen musst.

Wenn du mehr über das große Sprachmodell (LLM) erfahren willst, das Claude Code antreibt, schau dir diesen Artikel über Claude Sonnet 4.5 an.

Was sind Claude-Code-Hooks?

Claude Code Hooks sind shell-Befehle, die automatisch ablaufen, wenn während deiner KI-Programmier-Session bestimmte Sachen passieren. Stell dir diese als automatische Auslöser vor, die deine benutzerdefinierten Skripte zu genau festgelegten Zeitpunkten ausführen–bevor Claude eine Datei schreibt, nachdem es einen Befehl ausgeführt hat oder wenn es dir eine Benachrichtigung sendet.

Das System checkt, was Claude Code so macht, und vergleicht das mit den Regeln, die du in einer Konfigurationsdatei festlegst. Wenn es zu einer Übereinstimmung kommt, wird dein angegebener Befehl ausgeführt und hat Zugriff auf den Kontext dessen, was gerade passiert ist. Damit kannst du Claudes Verhalten steuern und wiederkehrende Aufgaben automatisieren, die sonst manuell erledigt werden müssten.

Hier ist ein einfacher Hook, der jedes Mal, wenn Claude eine Python-Datei schreibt, einen Code-Formatierer ausführt:

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

Dieser Haken besteht aus drei Teilen: 

• Das Ereignis: PostToolUse (nachdem Claude eine Aktion beendet hat)

• Der Matcher: Write (nur beim Schreiben von Dateien)

• Der Befehl: python -m black . (Python-Dateien im aktuellen Verzeichnis formatieren)

Der Hook kriegt detaillierte Infos darüber, was Claude gerade gemacht hat, über JSON-Daten, die an den Input des Skripts geschickt werden. So kannst du komplexere Automatisierungen erstellen, die auf bestimmte Dateiänderungen reagieren.

Wenn du dich für Automatisierung jenseits von Programmier-Workflows interessierst, bietet Claude Cowork eine ähnliche KI-gestützte Automatisierung für Datei- und Dokumentenaufgaben.

Als Nächstes schauen wir uns an, wie du solche Hooks von Grund auf neu erstellen und in Claude Code registrieren kannst, um sie deinen Workflows hinzuzufügen.

Was du brauchen solltest

Bevor du dich mit Claude Code Hooks beschäftigst, musst du ein paar Sachen einrichten:

• Claude Code ist installiert und läuft: Du solltest Claude Code für einfache Programmieraufgaben gut beherrschen.

• Vertrautheit mit der Befehlszeile: Hooks führen shell-Befehle aus, also musst du wissen, wie man grundlegende Terminalbefehle für dein Betriebssystem schreibt.

• Zugang zum Texteditor: Du wirst JSON-Konfigurationsdateien bearbeiten, um deine Hooks einzurichten.

• Projektverzeichnis: Ein Programmierprojekt, bei dem du Hooks sicher testen kannst, ohne wichtige Arbeiten zu stören.

Du musst kein Experte für shell-Skripte sein, aber wenn du weißt, wie man Befehle wie „ ls “, „ cd “ und grundlegende Dateioperationen ausführt, kannst du den Beispielen besser folgen. Wenn du noch keine Erfahrung mit Bash-Skripten oder dem Terminal hast, empfehle ich dir, unsere Einführung in Shell zu machen.

Erste Schritte mit Claude Code Hooks

Jetzt, wo du weißt, was Hooks sind, lass uns deine erste Automatisierung einrichten. Der Prozess umfasst die Auswahl des richtigen Ereignisses für deine Bedürfnisse, die Konfiguration einer einfachen Regel und das Testen dieser Regel mit einem grundlegenden Befehl.

Hook-Ereignisse verstehen

Claude Code bietet zehn verschiedene Ereignisse, bei denen du deine Befehle ausführen kannst. Jedes Ereignis wird zu einem bestimmten Zeitpunkt ausgelöst, sodass du die Kontrolle über verschiedene Teile deines Arbeitsablaufs hast:

PreToolUse Die häufigsten Ereignisse sind „ PostToolUse “ (Ereignis vor der Ausführung). „ PreToolUse “ (Ereignis vor der Ausführung) läuft, bevor Claude was macht, wie zum Beispiel eine Datei schreiben oder einen Befehl ausführen. Das ist super für die Validierung oder das Blockieren gefährlicher Vorgänge. „ PostToolUse “ (Ereignis nach der Ausführung) läuft, nachdem Claude eine Aktion abgeschlossen hat. Das eignet sich gut für Aufräumaufgaben wie das Formatieren von Code oder das Ausführen von Tests.

UserPromptSubmit wird ausgelöst, wenn du eine Eingabe an Claude sendest, bevor deine Anfrage verarbeitet wird. Du kannst das nutzen, um deiner Unterhaltung mehr Kontext zu geben oder um zu checken, ob die Eingabeaufforderungen bestimmte Anforderungen erfüllen.

Notification wird ausgeführt, wenn Claude dir Benachrichtigungen schickt, z. B. um die Erlaubnis zum Ausführen eines Befehls zu bitten oder wenn deine Eingabe gebraucht wird. „ PermissionRequest “ wird ausgelöst, wenn Claude Code einen Berechtigungsdialog anzeigt, sodass du die Anfrage automatisch im Namen des Benutzers genehmigen oder ablehnen kannst.

Stop und „ SubagentStop “ werden ausgelöst, wenn Claude mit der Antwort fertig ist. Das ist praktisch für letzte Überprüfungen oder zum Erstellen von Berichten. Der Unterschied zwischen den beiden ist, dass „ Stop “ ausgelöst wird, wenn Claude seine gesamte Antwort fertiggestellt hat, während „ SubagentStop “ ausgelöst wird, wenn ein von einem Tool erzeugter Helfer (ein „Subagent“) seine Arbeit beendet hat.

Die restlichen Ereignisse, PreCompact und SessionStart, kümmern sich um spezielle Sachen wie das Aufräumen von Unterhaltungen und das Starten von Sitzungen.

Die restlichen Ereignisse „ PreCompact “, „ SessionStart “ und „ SessionEnd “ kümmern sich um bestimmte Situationen im Lebenszyklus. „ PreCompact “ läuft, kurz bevor Claude den Gesprächsverlauf kürzt. „SessionStart“ wird zu Beginn einer neuen Sitzung ausgelöst, um Standardeinstellungen festzulegen, und „ SessionEnd “ wird beim Beenden der Sitzung ausgelöst, um Bereinigungen oder abschließende Reporting zu ermöglichen.

Matchers verstehen

Matchers sind Filter, die entscheiden, welche Claude Code-Aktionen einen Hook auslösen. Technisch gesehen sind das Zeichenfolgen, die als reguläre Ausdrücke interpretiert werden, sodass du entweder exakte Übereinstimmungen oder flexiblere Muster verwenden kannst. 

Die wichtigsten Matcher sind einfache wie „ Write “ (wird ausgelöst, wenn Claude eine Datei schreibt) oder „ Edit “ (wird ausgelöst, wenn Inhalte bearbeitet werden) sowie Kombinationen wie „ Edit|Write “, um mehrere Aktionen abzudecken. 

Du kannst auch Präfixmuster wie Notebook.* verwenden, um alle Tools zu finden, die mit „Notebook“ anfangen. Wenn du willst, dass der Hook bei jeder Aktion ausgelöst wird, nimm den universellen regulären Ausdruck „ .* “, eine leere Zeichenfolge („"" “) oder lass „ matcher “ einfach leer.

Da Matcher zwischen Groß- und Kleinschreibung unterscheiden und nur auf Aktionsnamen wirken, solltest du sie so spezifisch wie möglich halten. Wenn du mehr Kontrolle brauchst (z. B. um den Hook auf bestimmte Dateitypen zu beschränken), kannst du die JSON-Nutzlast lesen, die Claude an den Hook übergibt, und dort deine eigenen regulären Ausdrücke oder Bedingungen anwenden.

Erstellen deines ersten Hooks in Claude Code

Claude Code bietet zwei Möglichkeiten, Hooks einzurichten: über den interaktiven Befehl „ /hooks “ oder durch direktes Bearbeiten der Konfigurationsdateien. Fangen wir mit dem interaktiven Ansatz an, weil der für Anfänger einfacher ist.

Mit dem Befehl „ /hooks “:

1. Öffne Claude Code und tippe /hooks in die Chat-Oberfläche.

2. Such dir dein Trigger-Ereignis aus (in diesem Beispiel „ PostToolUse “).

3. Wähle im Menü „Neuen Hook hinzufügen” aus.

4. Leg dein Matcher-Muster fest (gib „ Write “ ein, um das Schreiben von Zieldateien zu aktivieren)

5. Gib deinen Befehl ein:

• Mac: say "Task complete"

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

• Linux: spd-say "Task complete"

6. Speicher die Konfiguration und geh zurück zu Claude Code, indem du dreimal Esc drückst.

Der Befehl „ /hooks “ aktualisiert automatisch deine Einstellungsdatei und lädt die Konfiguration neu. Du kannst auch jederzeit „ /hooks “ nutzen, um deine bestehenden Hooks anzusehen oder Änderungen vorzunehmen.

Wenn du es lieber magst, Konfigurationsdateien direkt zu bearbeiten, findest du Hooks für globale Einstellungen unter ~/.claude/settings.json und für dein Projektverzeichnis unter .claude/settings.json. Für unser Beispiel oben würde das so aussehen:

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

Nachdem du die Datei manuell bearbeitet hast, starte Claude Code neu oder benutze den Befehl „ /hooks “, um deine Konfiguration neu zu laden. Jetzt hörst du jedes Mal, wenn Claude eine Datei schreibt, eine Audiobenachrichtigung.

Deinen Haken testen

Bevor du weitermachst, check mal, ob dein Hook wirklich funktioniert:

1. Bitte Claude, irgendeine Python-Datei zu schreiben (z. B. „Erstelle eine Datei hello.py, die hello world ausgibt“).

2. Du solltest die Audiobenachrichtigung hören, wenn Claude den Schreibvorgang abgeschlossen hat.

3. Wenn du nichts hörst, schau mal in Claude Codes Protokoll nach, indem du Strg-O drückst, um eventuelle Fehlermeldungen zu sehen.

4. Häufige Probleme sind, dass der Befehl „hook“ nicht gefunden wird, falsche Dateiberechtigungen oder Syntaxfehler in deiner Konfigurationsdatei.

Wenn du diesen Basistest zum Laufen bringst, sparst du später Zeit beim Debuggen, wenn du komplexere Hooks erstellst. Wenn du gerade die Einstellungsdatei manuell bearbeitet, einen Matcher oder ein Ereignis geändert oder neue Tools installiert hast, die du in einem Hook-Befehl verwenden möchtest, kann es helfen, /hooks erneut zu öffnen oder Claude neu zu starten, um die Konfiguration neu zu laden.

Dieses Grundmuster – Ereignis, Matcher, Befehl – ist die Basis für die ganze Hook-Automatisierung. Du kannst das erweitern, indem du mehrere Befehle hinzufügst, die gleichzeitig ausgeführt werden, wenn dasselbe Ereignis passiert. Du möchtest vielleicht sowohl einen Ton abspielen als auch ein Backup erstellen, wenn Claude eine Datei schreibt. 

Du kannst auch separate Matcher für verschiedene Tools innerhalb desselben Ereignisses erstellen, sodass das Schreiben von Dateien andere Aktionen auslöst als das Bearbeiten von Code. Alle Haken, die zum gleichen Werkzeugmuster passen, laufen parallel. Wenn du mehrere Matcher für dasselbe Ereignis einrichtest, läuft jeder Hook, wenn sein Matcher ausgelöst wird.

Arbeiten mit Hook-Eingängen

Wenn Claude Code einen Hook auslöst, schickt es Infos über das, was gerade passiert ist, über die Standardeingabe (stdin), einen Datenstrom, der direkt zu deinem Befehl fließt, wenn er ausgeführt wird. Diese Daten machen Hooks so mächtig und nicht nur zu irgendwelchen Skripten, die zu beliebigen Zeiten laufen. 

Claude Code packt diese Infos als JSON und gibt sie an den Befehl weiter, den du eingestellt hast, egal ob es ein einfacher Terminalbefehl oder ein benutzerdefiniertes Skript ist.

Wie Hook-Eingaben funktionieren

Jeder Hook kriegt ein JSON-Objekt mit grundlegenden Feldern zur aktuellen Sitzung:

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

Lass uns die einzelnen Teile übersetzen:

• session_id: zeigt deine aktuelle Unterhaltung an

• transcript_path: zeigt auf den Gesprächsverlauf

• cwd: zeigt das Arbeitsverzeichnis an

• hook_event_name: sagt dir, welches Ereignis ausgelöst wurde

Mit diesem Kontext können deine Hooks kluge Entscheidungen treffen: Du kannst nachverfolgen, welche Unterhaltung eine Aktion ausgelöst hat, bei Bedarf auf den kompletten Chat-Verlauf zugreifen oder Befehle im richtigen Verzeichnis ausführen.

Ereignisbasierte Eingabevariationen

Tool-Ereignisse wie PreToolUse und PostToolUse haben zusätzliche Infos zur Aktion, und da sind Hooks echt nützlich für die Automatisierung. In PreToolUse wird „ tool_input ” angegeben, und „ tool_response ” zusätzlich in 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
  }
}

Im Hook-Eingabefeld zeigt „ file_path “ den Pfad der Datei, die gerade geschrieben oder bearbeitet wird, während „ content “ den genauen Text enthält, den das Tool schreiben wird. Nach dem Ausführen zeigt das Tool die letzte Datei „ filePath “ (beachte die Groß-/Kleinschreibung) an, um zu zeigen, welche Datei tatsächlich geändert wurde, zusammen mit einem „ success “-Flag, das sagt, ob der Vorgang erfolgreich war. 

Dank dieser detaillierten Infos können deine Hooks unterschiedlich reagieren, je nachdem, was wirklich passiert ist. Du kannst nur Python-Dateien formatieren, nur wichtige Verzeichnisse sichern oder Benachrichtigungen nur dann senden, wenn bestimmte Dateitypen geändert werden.

Ereignisse wie „ UserPromptSubmit ” sind einfacher, weil sie keine Tools brauchen:

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

Beachte, dass Hooks vom Typ „ UserPromptSubmit “ keine Matcher in ihrer Konfiguration verwenden. Sie werden bei allen Eingabeaufforderungen ausgelöst, nicht bei Werkzeugoperationen. Das macht sie super, um Gespräche zu protokollieren, automatisch Projektkontext hinzuzufügen oder Eingabeaufforderungen zu überprüfen, bevor Claude sie verarbeitet.

Lesen von Hook-Eingaben in der Praxis

Lass uns einen Hook erstellen, der jede Benutzeraufforderung protokolliert. Das löst das Problem, dass du den Überblick verlierst, was du Claude aufgetragen hast, vor allem bei langen Programmiersessions. Zuerst die Konfiguration des Hakens:

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

Als Nächstes machst du das Python-Skript unter ~/.claude/log_prompts.py mit dem folgenden Inhalt:

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

Das Skript liest die JSON-Daten, die Claude Code schickt, und speichert die Eingabeaufforderung zusammen mit dem Sitzungskontext. So entsteht ein durchsuchbarer Verlauf deiner Interaktionen, der echt nützlich ist, wenn du dich Wochen später daran erinnern musst, wie du ein Problem gelöst hast.

Arbeiten mit Hook-Ausgaben

Nachdem dein Hook-Befehl ausgeführt wurde, muss er Claude Code mitteilen, was passiert ist und ob er normal weiterlaufen soll. Dieser Kontrollmechanismus macht aus Hooks mehr als nur einfache Protokollierungswerkzeuge – sie werden zu einer starken Workflow-Automatisierung, die Claudes Verhalten steuern kann. Das läuft über drei Kanäle: Standardausgabe (stdout), Standardfehler (stderr) und Exit-Codes.

Ausgabekanäle und Exit-Codes

Standardausgabe (stdout) heißt normale Ausgabe. Wenn du zum Beispiel was ausdruckst, landet es unter stdout. Bei den meisten Hooks wird das hier in Claude Codes Transkript angezeigt, wenn du Strg-O drückst. So bekommst du eine Aufzeichnung dessen, was deine Automatisierung gemacht hat, ohne die Hauptkonversation zu überladen.

Standardfehler (stderr) bezieht sich auf Fehlermeldungen. Du kannst an stderr schreiben unter Verwendung von 

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

• Befehlszeile: echo "message" >&2

Der Hauptunterschied ist, dass „ stderr “ direkt an Claude geschickt werden kann, um automatisch verarbeitet zu werden, sodass es auf Probleme reagieren kann, die deine Hooks erkennen.

Exit-Codes sagen Claude Code, was als Nächstes zu tun ist:

• Exit-Code 0: Erfolg (zeigt dem Nutzer „ stdout “ an)

• Exit-Code 2: Blockierungsfehler (schickt „ stderr “ an Claude)

• Exit-Code 3: Aufgeschobene Ausführung (bedeutet, dass der Befehl ohne Fehler abgeschlossen wurde, seine Auswirkungen aber erst dann passieren, wenn noch ein paar Bedingungen erfüllt sind) 

• Andere Codes: Nicht blockierender Fehler (zeigt dem Benutzer „ stderr “ an, läuft aber weiter)

Mit diesem System kannst du genau steuern, wann Claude aufhören, weitermachen oder Feedback zu den Ergebnissen deiner Automatisierung bekommen soll. Schauen wir uns mal Beispiele für die beiden wichtigsten Exit-Codes an.

Exit-Code 0: Normalbetrieb

Die meisten Hooks benutzen den Exit-Code 0, um anzuzeigen, dass alles gut gelaufen ist. Hier ist ein kompletter Hook, der Dateioperationen protokolliert und den Benutzer benachrichtigt:

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

Dieser Hook macht zwei Sachen: Er schreibt was in eine Datei und druckt dann 'ne Meldung ins Protokoll. Es gibt viele Möglichkeiten, das zu machen, aber dieser Ansatz funktioniert auf allen Plattformen und man muss sich nicht mit den Besonderheiten der Befehlszeile rumschlagen.

Da es keinen expliziten Exit-Code gibt, ist der Standardwert 0. Die gedruckte Nachricht erscheint im Protokoll von Claude Code und zeigt dir, dass die Protokollierung geklappt hat. Dieses Muster ist super, um Prüfpfade zu erstellen oder zu verfolgen, welche Änderungen Claude im Laufe der Zeit an deinem Projekt vornimmt.

Exit-Code 2: Blockieren mit Feedback

Der Exit-Code 2 schickt deine Fehlermeldung direkt an Claude, damit es automatisch antworten kann. Hier werden Hooks zu einem Sicherheitsmechanismus und sind nicht mehr nur eine Automatisierung. Hier ist ein Hook, der gefährliche Dateioperationen blockiert:

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

Du musst das Skript für die Sicherheitsüberprüfung unter ~/.claude/security_check.py erstellen:

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

Wenn dieser Hook einen gefährlichen Pfad findet, bricht er mit dem Code 2 ab. Claude Code schickt die stderr-Meldung an Claude, der dir dann erklären kann, warum der Vorgang blockiert wurde, und dir Alternativen vorschlagen kann. Das verhindert, dass Systemdateien aus Versehen beschädigt werden, und hält Claude über deine Sicherheitsrichtlinien auf dem Laufenden.

Einen intelligenten Benachrichtigungs-Hook für Claude Code erstellen

Lass uns unseren verbesserten Benachrichtigungs-Hook erstellen, der die Eingabeverarbeitung mit einer intelligenten Ausgabeverarbeitung kombiniert. Das löst das Problem mit den Störgeräuschen von unserem ursprünglichen Hook, der bei jeder Dateiänderung Alarm schlug:

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

Mach das Benachrichtigungsskript unter „ ~/.claude/smart_notify.py “ (Benachrichtigungsskript erstellen):

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

Dieser Hook liest die Eingabe, um zu sehen, welche Datei geändert wurde, entscheidet anhand des Dateityps, wie wichtig die Benachrichtigung ist, nutzt stdout, um wichtige Änderungen im Protokoll zu loggen, löst je nach Dateityp verschiedene Audio-Warnungen aus und beendet sich immer mit dem Code 0, weil es sich um informative Aktionen handelt, die nichts blockieren.

Die Kombination aus Eingabeanalyse und Ausgabesteuerung schafft einen Haken, der sich je nach Kontext intelligent verhält und dir und Claude Code gleichzeitig das richtige Maß an Feedback gibt. Statt nervige Benachrichtigungen für jede temporäre Datei zu kriegen, erfährst du nur von Änderungen, die für dein Projekt wirklich wichtig sind.

Hey, dieses Beispiel nutzt den Befehl „ say “, den du auf macOS findest. Unter Linux kannst du „ notify-send “ verwenden, und unter Windows einen PowerShell-Befehl, um ähnliche Benachrichtigungen zu bekommen.

Fortgeschrittene Muster für Claude-Code-Hooks

Über einfache Benachrichtigungen und Protokollierung hinaus können Hooks echte Probleme im Entwicklungs-Workflow lösen, mit denen Teams täglich konfrontiert sind. Hier sind ein paar Ideen, die du für deine eigenen Projekte anpassen kannst.

Das Tolle daran ist, dass du diese Hooks nicht wirklich manuell erstellen musst. Du kannst Claude Code einfach eine der unten aufgeführten Ideen zusammen mit dem Verweis auf Hooks in der Dokumentation geben, und es wird den entsprechenden Code und JSON für die Konfiguration generieren.

Jedes dieser Muster kann an deine speziellen Tools und deinen Arbeitsablauf angepasst werden. Fang mit den Sachen an, die dir im Alltag am meisten Stress machen, und baue dann deine Automatisierung aus, wenn du dich mit der Hook-Entwicklung besser auskennst.

Erweiterte Hooks für Sicherheit und Compliance

API-Schlüssel-Scanner

• Problem: Versehentlich Geheimnisse in die Versionskontrolle übertragen

• Auslöser: Bevor du eine Datei schreibst

• Lösung: Dateiinhalte nach API-Schlüsseln, Tokens und Passwörtern mit regulären Ausdrücken durchsuchen

Mach ein Python-Skript, das die Hook-Eingabe JSON liest, den Dateiinhalt extrahiert und mit Regex-Mustern gängige geheime Formate wie api_key=, token: oder password= erkennt.  Bei verdächtigen Übereinstimmungen solltest du eine lokale Überprüfung machen und niemals unverarbeitete Geheimnisse nach draußen schicken. 

Schick nur maskierte Ausschnitte (z. B. behalte 4 Zeichen vor/nach dem Präfix/Suffix) oder Hashes an die Anthropic-API, um verdächtige Zeichenfolgen zu checken und festzustellen, ob es sich um echte Geheimnisse oder nur um Variablennamen handelt. Beende den Vorgang mit Code 2 und gib Claude Feedback zu den gefundenen Geheimnissen und sichereren Alternativen.

Lizenz-Header-Enforcer

• Problem: Open-Source-Projekte, bei denen die erforderlichen Lizenz-Header in neuen Dateien fehlen

• Auslöser: Bevor du Quellcode-Dateien schreibst

• Lösung: Überprüfe, ob die neuen Dateien „ .py “, „ .js “ und „ .java “ den richtigen Lizenztext haben.

Analysiere die Hook-Eingabe, um den Dateiinhalt zu bekommen, und schau mit String-Matching nach, ob die ersten 10 Zeilen den Lizenztext haben. Für eine genauere Überprüfung schick den Dateikopf über die Anthropic-API an Claude, um sicherzugehen, dass er die richtigen Copyright-Hinweise und Lizenzinfos enthält. Blockier die Erstellung von Dateien mit dem Exit-Code 2, wenn Header fehlen, und gib Claude die richtige Lizenzvorlage, die er hinzufügen soll.

Produktionsdatei-Schutz

• Problem: Versehentliches Ändern wichtiger Systemkonfigurationsdateien

• Auslöser: Bevor du Dateien in sensiblen Verzeichnissen bearbeitest

• Lösung: Änderungen an „ /etc/ “, „ nginx.conf “, „ database.yml “ und anderen wichtigen Konfigurationen blockieren

Hol den Dateipfad aus der Hook-Eingabe-JSON raus und schau nach, ob er mit Mustern wie /etc/, production.yml oder anderen kritischen Dateinamen übereinstimmt. Nutze Claudes API, um den Dateipfad zu checken und festzustellen, ob es sich um eine Konfigurationsdatei handelt, die sich auf Produktionssysteme auswirken könnte. Beende den Vorgang mit Code 2 und gib konkrete Tipps für sicherere Entwicklungsmethoden, wenn gefährliche Pfade gefunden werden.

Bildoptimierer

• Problem: Große Bilddateien machen Anwendungen und Repositorys langsamer

• Auslöser: Nachdem du neue Bilddateien hinzugefügt hast

• Lösung: PNG/JPEG-Dateien komprimieren, ohne dass die Bildqualität darunter leidet

Analysiere die Hook-Eingabe, um den Dateipfad zu bekommen, und schau nach, ob es eine Bilddatei ist, indem du die Dateiendung vergleichst. Benutz Komprimierungsprogramme wie imageoptim oder ruf die TinyPNG-API auf, um das Bild zu komprimieren, ohne dass die Qualität leidet. Schreib die Komprimierungsergebnisse in „ stdout “, damit du die Einsparungen bei der Dateigröße in Claudes Transkript sehen kannst.

Erweiterte Hooks für die Automatisierung der Versionskontrolle

Git-Zweig-Validator

• Problem: Teammitglieder, die aus Versehen Änderungen an geschützten Branches pushen

• Auslöser: Bevor du irgendwelche Dateien schreibst oder bearbeitest

• Lösung: Überprüfe den aktuellen Git-Zweig und blockiere Vorgänge auf main/master/production.

Benutz einfach den Bash-Befehl „ git branch --show-current “, um den aktuellen Branch-Namen zu kriegen und ihn mit einer Liste geschützter Branches zu vergleichen. Wenn du dich in einem geschützten Zweig befindest, beende den Vorgang mit Code 2 und schick Claude eine Fehlermeldung, in der du die Richtlinien zum Schutz von Zweigen erklärst. Bei komplizierten Regeln für die Benennung von Branches kannst du Claudes API nutzen, um die Namen der Branches zu checken und zu sehen, ob sie mit den Schutzmustern übereinstimmen.

Intelligente automatische Bestätigung

• Problem: Vergessen, Änderungen zu committen, oder schlechte Commit-Meldungen schreiben

• Auslöser: Nach jeder Dateiänderung

• Lösung: Änderungen automatisch bereitstellen und festschreiben mit KI-generierten beschreibenden Meldungen

Lies die geänderten Dateipfade aus der Hook-Eingabe, führe „ git diff “ aus, um die Änderungen zu bekommen, und schick den Diff an Claudes API mit einer Aufforderung, eine kurze Commit-Nachricht einzugeben. Benutz die erstellte Nachricht mit den Befehlen „ git add “ und „ git commit “, um die Änderungen automatisch zu übernehmen. Füge Dateinamen und Änderungstypen in die API-Eingabeaufforderung ein, damit die Commit-Meldungen den üblichen Commit-Standards entsprechen.

Dokumentationsgenerator

• Problem: API-Dokumentation stimmt nicht mehr mit Code-Änderungen überein

• Auslöser: Nach dem Ändern der Schnittstellendateien (Controller, Modelle, APIs)

• Lösung: Automatisches Ausführen von Dokumentationstools wie JSDoc, Sphinx oder OpenAPI-Generatoren

Überprüfe den geänderten Dateipfad, um festzustellen, ob es sich um eine API-Endpunkt-, Modell- oder Schnittstellendatei handelt, indem du Mustervergleiche machst. Schick den Inhalt der Datei an Claudes API und bitte sie, API-Änderungen zu extrahieren und Aktualisierungen der Dokumentation zu erstellen. Starte das passende Tool zum Erstellen von Dokumentationen (jsdoc, sphinx-build usw.) und speichere die aktualisierte Dokumentation automatisch.

Erweiterte Hooks für Zusammenarbeit und Workflow-Integration

Slack-Integration

• Problem: Das Team weiß nichts von wichtigen Änderungen an gemeinsamen Codebasen.

• Auslöser: Wenn Benachrichtigungen für wichtige Vorgänge verschickt werden

• Lösung: Formatierte Nachrichten mit Dateinamen und Änderungszusammenfassungen in Teamkanälen posten

Hol dir die Datei-Infos aus dem Hook-Input raus und filter wichtige Dateitypen wie Quellcode oder Konfigurationsdateien raus. Nutze Claudes API, um eine leicht verständliche Zusammenfassung der Änderungen zu erstellen, basierend auf Dateinamen und -typen. Schick die formatierte Nachricht über Webhook-URLs mit Erwähnungen von Teammitgliedern für wichtige Änderungen an Slack.

Webhook-Dispatcher

• Problem: Manuelle CI/CD-Pipeline-Auslöser, die zu Verzögerungen bei der Bereitstellung führen

• Auslöser: Wenn bestimmte Sachen passieren (Konfigurationsänderungen, geänderte Bereitstellungsdateien)

• Lösung: Externe APIs aufrufen, um Builds, Bereitstellungen oder andere automatisierte Prozesse zu starten

Schau mal, ob der geänderte Dateipfad mit Mustern wie „ Dockerfile “, „ package.json “ oder Bereitstellungskonfigurationen übereinstimmt, um zu sehen, ob CI/CD loslegen soll. Benutze die Requests-Bibliothek in Python, um Webhook-URLs mit Authentifizierungs-Headern und Nutzdaten zu den Änderungen aufzurufen. Füge Dateipfade hinzu und ändere die Metadaten in der Webhook-Nutzlast, damit externe Systeme kluge Entscheidungen darüber treffen können, was erstellt oder bereitgestellt werden soll.

Status-Seite-Updater

• Problem: Kunden wissen nichts von Wartungs- oder Bereitstellungsaktivitäten

• Auslöser: Wenn Deployment- oder Infrastrukturdateien geändert werden

• Lösung: Aktualisiert die Servicestatus-Seiten mit Wartungsankündigungen.

Analysiere Hook-Eingaben für Änderungen an Infrastrukturdateien wie Kubernetes-Manifesten oder Terraform-Konfigurationen mithilfe von Dateipfadmustern. Erstelle Wartungsmeldungen mit Claudes API, je nachdem, welche Änderungen an der Infrastruktur du entdeckt hast. Schreib Status-Updates auf Dienste wie StatusPage.io oder PagerDuty über deren REST-APIs mit den passenden Vorfallstypen und der geschätzten Dauer.

Teamstatus-Benachrichtigung

• Problem: Probleme, wenn mehrere Entwickler ohne es zu wissen an denselben Funktionen arbeiten

• Auslöser: Wenn du eine neue Claude Code-Sitzung startest

• Lösung: Teile den Teamkanälen mit, dass du mit der Arbeit an einem bestimmten Projekt oder einer bestimmten Komponente anfängst.

Lies das Projektverzeichnis aus dem Hook-Input und nutze Claudes API, um die neuesten Dateien oder den Git-Verlauf zu checken, um zu sehen, welche Art von Arbeit gerade gemacht wird. Schick eine formatierte Nachricht mit deinem Namen, dem Projektnamen und dem Schwerpunktbereich an die Kommunikationskanäle des Teams. Gib die geschätzte Arbeitszeit an und sag den Teammitgliedern, sie sollen sich abstimmen, wenn sie an ähnlichen Features arbeiten.

Fazit

Claude Code Hooks verwandeln unberechenbare KI-Codierungsassistenten in automatisierte Arbeitsabläufe, die genau dann laufen, wenn du sie brauchst. In diesem Tutorial hast du gelernt, wie du Hooks sowohl mit dem interaktiven Befehl „ /hooks “ als auch durch manuelle Konfiguration einrichtest, die JSON-Eingabedaten verstehst, die die intelligente Automatisierung ermöglichen, und das Verhalten von Claude über Exit-Codes und strukturierte Ausgaben steuerst. 

Zu den praktischen Mustern, die wir behandelt haben, gehören Sicherheitsvalidatoren, die gefährliche Vorgänge blockieren, und intelligente Benachrichtigungen, die die Flut an Meldungen reduzieren. Diese Beispiele zeigen, wie Hooks echte Entwicklungsprobleme lösen und dir gleichzeitig die volle Kontrolle über deinen KI-Assistenten geben. Jetzt, wo du die Grundlagen kennst, kannst du eine Automatisierung aufbauen, die genau zu den Arbeitsabläufen deines Teams passt. 

Wenn du mehr über die Arbeit mit KI-Tools erfahren willst, schau dir den Kurs „Understanding Prompt Engineering“ von DataCamp an. Kurs „Understanding Prompt Engineering”an, der sich mit Prompting-Strategien beschäftigt, die direkt mit der Hook-Entwicklung zusammenhängen. Für umfassendere KI-Programmierkenntnisse probier doch mal unseren chatGPT-Kurs für Fortgeschrittene aus, um die Fähigkeiten zu entwickeln, die KI-Assistenten zu zuverlässigeren Partnern in deinem Entwicklungs-Workflow machen.