Wiederholung ist Zeitverschwendung

Szenario: Du brauchst für jeden API-Request die gleiche Boilerplate. Error Handling. Logging. Validation.

Das tippst du jedes Mal neu.

Oder: Du könntest einen Hook schreiben. Der macht es automatisch. Jedes Mal. Perfekt.

Das ist nicht Faulheit. Das ist Engineering.

Phase 1: Was sind Hooks?

Hooks sind Event-Listener für Claude Code.

Wenn bestimmte Dinge passieren, triggert Claude einen Hook.

Ein Hook ist einfach: Ein Script, das ausgeführt wird.

Beispiele:

```Event: User gibt Prompt einHook: Script lädt neueste Database-SchemaErgebnis: Claude hat frischen Context```

```Event: User sagt "@api-design"Hook: Script generiert API-TemplateErgebnis: Claude zeigt sofort das Template```

Verfügbare Hooks:

• pre-prompt-submit – Vor dem Absenden
• post-prompt-submit – Nach dem Absenden
• pre-response – Bevor Claude antwortet
• file-created – Wenn Datei erstellt wird
• file-modified – Wenn Datei geändert wird

Phase 2: Dein erstes Hook-Script

Hooks sind Scripts im .claude/hooks Verzeichnis.

Setup:

```mkdir -p .claude/hooks```

Dann erstelle eine Datei:

.claude/hooks/user-input.js

Einfaches Beispiel:

console.log("Hook triggered!");console.log("User input received");

Das war's. Dein erstes Hook-Script.

Registrieren:

Im Terminal:

claude

Dann:

/add-hook user-input-hook

Claude fragt nach:

• Event (z.B. pre-prompt-submit)
• Script-Pfad (.claude/hooks/user-input.js)

Speichern. Fertig.

Phase 3: Einfache Automatisierung – Logging

Praktisches Beispiel: Jeden Prompt mitprotokollieren.

.claude/hooks/log-prompt.js:

const fs = require('fs');const timestamp = new Date().toISOString();

function logPrompt(input) { const entry = { timestamp, prompt: input.prompt, project: process.cwd() }; const logFile = '.claude/prompt-log.json'; let logs = []; if (fs.existsSync(logFile)) { logs = JSON.parse(fs.readFileSync(logFile, 'utf-8')); } logs.push(entry); fs.writeFileSync(logFile, JSON.stringify(logs, null, 2));}

module.exports = logPrompt;

Was macht das?

• Liest jeden Prompt
• Speichert ihn mit Timestamp
• In eine prompt-log.json

Du hast jetzt einen kompletten Audit-Trail.

Phase 4: Context Loading – Der Power Move

Szenario: Jedes Mal, wenn ein Benutzer fragt, musst du ein bestimmtes Schema laden.

Hook:

.claude/hooks/load-schema.js:

const fs = require('fs');

function loadSchema() { const schema = fs.readFileSync('./db/schema.sql', 'utf-8'); return { context: schema, description: 'Database schema loaded' };}

module.exports = loadSchema;

Jetzt:

• Hook triggert vor jedem Prompt
• Schema wird automatisch geladen
• Claude hat immer frischen Context

Du fragst nie wieder: "Kennst du die Database-Struktur?"

Die Antwort ist immer ja.

Phase 5: Conditional Hooks – Nur wenn nötig

Nicht immer sollte ein Hook triggern. Nur unter bestimmten Bedingungen.

Beispiel: Lade das Payment-Schema nur, wenn der User "payment" erwähnt.

.claude/hooks/conditional-load.js:

function shouldLoadPaymentSchema(input) { const keyword = 'payment'; return input.prompt.toLowerCase().includes(keyword);}

function loadPaymentSchema() { const fs = require('fs'); const schema = fs.readFileSync('./schemas/payment.sql', 'utf-8'); return schema;}

if (shouldLoadPaymentSchema(userInput)) { const schema = loadPaymentSchema(); // Schema an Claude übergeben}

Jetzt:

• Hook prüft: "Sagt der User Payment?"
• Nur dann lädt er das Schema
• Rest der Zeit lädt er nix

Das spart Tokens. Massiv.

Phase 6: Bun – Das einfache Runtime

Hooks können in JavaScript oder TypeScript laufen.

Aber JavaScript in Node ist manchmal langsam.

Deswegen nutzen wir Bun: Ein schnellerer JavaScript/TypeScript Runner.

Installation:

curl -fsSL https://bun.sh/install | bash

Hook mit Bun:

Statt .js, nutze .ts:

.claude/hooks/load-config.ts:

import Bun from "bun";import { readFileSync } from "fs";

const config = JSON.parse( readFileSync("./config.json", "utf-8"));

console.log("Config loaded:", config);

Ausführen:

bun .claude/hooks/load-config.ts

Das ist 5x schneller als Node.

Phase 7: Verkettung – Mehrere Hooks

Du kannst mehrere Hooks hintereinander laufen lassen.

Beispiel:

1. Hook 1: Log den Prompt
2. Hook 2: Lade Schema
3. Hook 3: Validiere Input

```Hook 1 (logging) ↓Hook 2 (context loading) ↓Hook 3 (validation) ↓Claude antwortet```

Jeder Hook arbeitet, dann geht's zum nächsten.

Das ist eine Automation-Pipeline.

Phase 8: Fehlerbehandlung

Was, wenn ein Hook fehlschlägt?

Gute Frage.

.claude/hooks/safe-load.ts:

try { const data = JSON.parse(readFileSync("config.json", "utf-8")); console.log("Config loaded"); return data;} catch (error) { console.error("Failed to load config:", error.message); return { default: true };}

Jetzt:

• Hook versucht zu laden
• Falls Fehler → Fallback-Wert
• Claude arbeitet trotzdem weiter

Keine Crashes. Nur robustes Design.

Phase 9: Debugging Hooks

Hooks funktionieren nicht? Hier sind die Standard-Checks:

1. Script-Pfad prüfen

Ist .claude/hooks/myscript.ts wirklich da?

2. Syntax prüfen

Führe das Script manuell aus:

bun .claude/hooks/myscript.ts

Fehler?

3. Logs prüfen

Dein Hook schreibt Logs. Wo sind sie?

```.claude/hook-logs.json```

Darin siehst du, was passiert ist.

4. Settings prüfen

Hook registriert?

/settings

Zeigt alle Hooks an.

Phase 10: Real-World Example – Dokumentation automatisch laden

Vollständiges Hook-Beispiel:

.claude/hooks/load-docs.ts:

import { readFileSync } from "fs";import { existsSync } from "fs";

interface UserInput { prompt: string; cwd: string;}

export async function loadRelevantDocs(input: UserInput) { const docsPath = "./docs"; if (!existsSync(docsPath)) { return { success: false, message: "No docs found" }; } const files = readFileSync(docsPath, "utf-8"); const content = JSON.stringify(files); console.log("Loaded docs for context"); return { success: true, context: content, timestamp: new Date().toISOString() };}

Was macht das?

1. Checkt, ob ./docs existiert
2. Liest die Dateien
3. Gibt sie an Claude
4. Logged den Timestamp

Claude hat jetzt automatisch deine Dokumentation im Context.

Dein Action Plan für heute

1. ✅ Erstelle .claude/hooks Verzeichnis
2. ✅ Erstelle eine einfache log-input.js
3. ✅ Starte Claude Code
4. ✅ Registriere den Hook mit /add-hook
5. ✅ Gib einen Prompt ein
6. ✅ Checke die Logs

Wenn dein Prompt geloggt wurde, funktioniert dein Hook.

Die größte Erkenntnis

Hooks sind nicht optional. Sie sind die Brücke zwischen Manual und Automation.

Mit Hooks verwandelst du Claude Code von einem "Smart Chatbot" zu einem Automation Engine.

• Daten laden automatisch
• Kontext wird frisch gehalten
• Workflows sind konsistent

Das ist nicht nur schneller. Das ist professionell.

Nächste Woche: Prompt Rewriting – Wie du Claude anweist, deine Prompts intelligent zu transformieren.

Habt einen tollen Tag. Ciao.