Claude Code Best Practices: Von „nutzbar“ zu „wirklich nützlich“

Ich benutze Claude Code seit über einem halben Jahr und bin in mehr Fallstricke getappt, als ich Code-Zeilen geschrieben habe.

Anfangs dachte ich, Claude Code sei nur ein "fortgeschritteneres Copilot" – man tippt im Terminal ein, es schreibt Code, fertig. Später wurde mir klar, dass die Obergrenze dieses Tools viel höher liegt, als ich mir vorgestellt habe, aber nur, wenn man weiß, wie man es einsetzt.

Dieser Artikel kombiniert offizielle Dokumentation und praktische Erfahrung, um die meiner Meinung nach wichtigsten Nutzungstipps zu ordnen. Einige sind Lektionen, die ich auf die harte Tour gelernt habe, andere sind versteckte Funktionen, die ich erst durch das Lesen der Doku entdeckt habe.

1. CLAUDE.MD: Das am meisten unterschätzte Feature

Wenn Sie sich nur eine Sache aus diesem Artikel merken, dann diese: Schreiben Sie Ihre CLAUDE.md gut.

CLAUDE.md ist die Anweisungsdatei, die Claude Code automatisch zu Beginn jeder Konversation liest. Es ist wie ein Einführungsdokument, das Sie für einen neuen Kollegen schreiben – alles, was sie wissen sollen, schreiben Sie dort hinein.

Viele Leute schreiben keine CLAUDE.md oder nur ein paar Zeilen. Die Folge ist, dass sie in jeder Konversation die Projektstruktur, Codierungsstandards und Tech-Stack-Entscheidungen von Grund auf erklären müssen. Es ist, als würde man Ihrem Kollegen jeden Morgen das Unternehmen neu vorstellen.

Was eine gute CLAUDE.md enthalten sollte:

1# Projektname
2
3## Build- und Testbefehle
4- Abhängigkeiten installieren: npm install
5- Tests ausführen: npm test
6- Einzeltest: npm test -- --grep "Testname"
7- Formatierung: npm run format
8
9## Codierungsstandards
10- Python: ruff für Formatierung verwenden, Zeilenbreite 88
11- Tests: pytest verwenden, eine Testdatei pro Service
12- API-Routen: Dateinamen im Plural verwenden: users.py, orders.py
13- Commit-Nachrichten: Englisch, Format: type(scope): description
14
15## Architekturentscheidungen
16- Tailwind gegenüber CSS Modules wählen, weil das Team sich darauf geeinigt hat
17- Benutzerberechtigungsprüfungen erfolgen in Middleware; nicht in jeder Route wiederholen
18- Redis-Cache-Key-Präfix: app:v1:
19
20## Häufige Fallstricke
21- DB-Verbindungspool-Limit ist 20; keine neuen Verbindungen in Schleifen öffnen
22- Datenbank nicht mocken; letztes Mal bestanden Mocks, aber die Produktionsmigration schlug fehl

Wichtige Prinzipien:

Erstens, Dinge schreiben, die Claude nicht aus dem Code ableiten kann. Das "Warum" eines Projekts ist wichtiger als das "Was." Sie müssen nicht erklären, wie man React verwendet, aber Sie müssen ihm sagen "wir haben Tailwind gewählt, weil das Team sich darauf geeinigt hat."

Zweitens, unter 200 Zeilen halten. Die offizielle Doku erwähnt explizit, dass Claude Regeln ignorieren könnte, wenn CLAUDE.md zu lang ist. Verwenden Sie Markdown-Überschriften und Listen, um es überblickbar zu halten.

Drittens, keine häufig wechselnden Inhalte einfügen. Detaillierte API-Dokumentation oder dateispezifische Beschreibungen gehören nicht in CLAUDE.md. Geben Sie einfach Links an.

Die vier Ebenen von CLAUDE.md

Claude Code unterstützt vier Ebenen von CLAUDE.md, geordnet von höchster zu niedrigster Priorität:

In meiner globalen CLAUDE.md schreibe ich normalerweise:

1- Ich bin ein Full-Stack-Entwickler; keine Notwendigkeit, grundlegende Konzepte übermäßig zu erklären
2- Antworten präzise halten; unnötige Höflichkeiten weglassen
3- Nicht zusammenfassen, was nach Code-Änderungen getan wurde; ich werde den Diff prüfen
4- Einfache Lösungen priorisieren; Over-Engineering vermeiden

Diese vier Zeilen können Ihnen hunderte von wiederholten Korrekturen ersparen.

Fortgeschritten: Regeln mit .claude/rules/ organisieren

Wenn ein Projekt wächst, reicht eine CLAUDE.md-Datei nicht aus. Die offizielle Lösung ist eleganter: Regeln in das .claude/rules/-Verzeichnis aufteilen.

1.claude/rules/
2├── testing.md        # Teststandards
3├── api-style.md      # API-Schreibstil
4└── frontend.md       # Frontend-Konventionen

Noch leistungsfähiger: Sie können YAML-Frontmatter verwenden, um Regeln auf bestimmte Dateien zu beschränken:

1---
2paths: ["src/api/**/*.ts", "src/routes/**/*.ts"]
3---
4
5API-Routen müssen Eingabevalidierung und Fehlerbehandlung enthalten.
6Alle neuen Endpunkte benötigen Integrationstests in tests/api/.

Auf diese Weise wird die Regel nur geladen, wenn Claude auf passende Dateien zugreift, was Kontextplatz spart.

2. Prompt-Qualität bestimmt Ausgabequalität

Das klingt nach einer Plattitüde, aber ich habe zu viele Leute gesehen, die Claude Code so verwenden:

"Hilf mir, eine Login-Funktion zu schreiben"

Dann machen sie sich Sorgen über einen riesigen Haufen generierten Codes – das wollte ich nicht.

Eine gute Anweisung sollte drei Elemente enthalten: Ziel, Einschränkungen und Kontext.

Schlechte Anweisung vs. Gute Anweisung

Schlecht: "Füge eine Suchfunktion zur Benutzerliste hinzu"

Gut: "Füge ein Suchfeld über der Tabelle in @src/pages/UserList.tsx hinzu. Die Suche soll die Backend-API /api/users?search=xxx verwenden, kein Frontend-Filter. Verwende eine 300ms-Entprellung und halte den Stil konsistent mit der bestehenden Filter-Komponente."

Der Unterschied? Gute Anweisungen reduzieren Mehrdeutigkeit. Claude Code muss nicht raten, ob Sie Frontend- oder Backend-Suche, die Entprellzeit oder die Stilstandards wollen.

Offiziell empfohlene Prompt-Tipps

1. Verwenden Sie @, um auf bestimmte Dateien zu verweisen

Claude Code unterstützt die Verwendung von @dateipfad, um Dateiinhalte direkt in den Kontext zu ziehen. Anstatt "diesen auth-bezogenen Code" zu sagen, ist das Schreiben von @src/auth/login.ts viel präziser. Sie können sogar Zeilenbereiche angeben: @src/auth/login.ts#5-30.

2. Screenshots und Bilder einfügen

Verwenden Sie Strg+V, um Bilder direkt einzufügen. Beim Debuggen von UI-Problemen ist ein Screenshot von "wie es jetzt aussieht" vs. "wie ich es haben möchte" zehnmal effektiver als eine Textbeschreibung.

3. Validierungskriterien angeben

Sagen Sie nicht nur "hilf mir, diesen Bug zu beheben", sondern:

"Behebe das Problem, dass die erneute Authentifizierung nach einem Login-Timeout fehlschlägt. Nach der Behebung sollte das Klicken auf eine beliebige Schaltfläche nach Token-Ablauf automatisch zur Login-Seite weiterleiten. Testfälle sind in @tests/auth.test.ts; führe sie aus, um zu bestätigen, dass sie nach der Behebung bestehen."

Geben Sie Claude einen selbstüberprüfbaren Standard – Testfälle, Screenshots, erwartete Ausgabe – damit es seine eigene Arbeitsqualität überprüfen und Hin und Her reduzieren kann.

4. Seien Sie klar, was NICHT getan werden soll

Claude Code kann manchmal übereifrig sein – Sie bitten es, einen Bug zu beheben, und es refaktoriert den umliegenden Code mit. Explizit zu sagen "ändere nur diese Funktion, fasse anderen Code nicht an" spart viel Ärger.

Wann vage Anweisungen nützlich sind

Nicht jede Situation erfordert Präzision. Vage Anweisungen sind tatsächlich besser für explorative Aufgaben:

• "Was kann in dieser Datei verbessert werden?"
• "Hilf mir, die Architektur dieses Moduls zu verstehen"
• "Gibt es potenzielle Probleme mit diesem Code?"

Aber sobald Sie die Implementierungsphase erreichen, wechseln Sie zurück in den Präzisionsmodus.

3. PLAN-MODUS: Klar denken, bevor Sie handeln

Claude Code hat einen Plan-Modus, den ich für den am meisten unterschätzten Workflow halte.

Wie man in den Plan-Modus gelangt

Drei Wege:

1# Direkt im Plan-Modus starten
2claude --permission-mode plan
3
4# Während des Gesprächs wechseln (Shift+Tab zweimal drücken)
5Shift+Tab Shift+Tab
6
7# Im Prompt sagen
8"Ändere den Code noch nicht, hilf mir, einen Plan zu erstellen"

Im Plan-Modus kann Claude Code nur Dateien lesen und Code durchsuchen; es kann keine Änderungen vornehmen. Es erkundet die Codebasis, analysiert Ihre Anforderungen und liefert einen detaillierten Implementierungsplan.

Richtige Verwendung des Plan-Modus

Wichtige Aktion: Drücken Sie Strg+G, um den Plan im Editor zu öffnen und zu bearbeiten.

Das bedeutet, Sie können:

1. Claude einen ersten Plan generieren lassen
2. Strg+G, um den Plan zu öffnen, Teile löschen, mit denen Sie nicht einverstanden sind, und eigene Ideen hinzufügen
3. Zurück in den Normalmodus wechseln (Shift+Tab) und Claude den geänderten Plan ausführen lassen

Einen Plan zu ändern dauert einen Satz; bereits geschriebenen Code zu ändern dauert zehnmal länger.

Empfohlener Workflow für komplexe Aufgaben

Der offizielle Standardprozess umfasst vier Schritte: Erkunden → Planen → Implementieren → Verifizieren.

11. Plan-Modus betreten
22. Claude relevanten Code lesen lassen: "Lies den Code in src/auth/, um die Session-Logik zu verstehen"
33. Einen Plan anfordern: "Entwickle einen OAuth2-Migrationsplan"
44. Strg+G, um den Plan zu überprüfen und zu bearbeiten
55. Zurück in den Normalmodus wechseln
66. "Gemäß dem Plan implementieren, nach dem Schreiben Tests ausführen"
77. Claude die Arbeit gegen die Anforderungen selbst überprüfen lassen

Wann Sie den Plan-Modus nicht benötigen

• Ändern eines Variablennamens
• Beheben eines offensichtlichen Tippfehlers
• Hinzufügen einer einzelnen Log-Zeile

Das Kriterium ist einfach: Wenn es nur eine Möglichkeit gibt, die Aufgabe zu implementieren, machen Sie es direkt. Wenn es mehrere Möglichkeiten gibt, planen Sie zuerst.

4. SUB-AGENTS: Die Multitasking-Fähigkeit von Claude Code

Sub-Agents sind ein leistungsfähiger Mechanismus – Claude Code kann unabhängige KI-Prozesse starten, um Aufgaben parallel zu erledigen. Jeder Sub-Agent hat seinen eigenen Kontextfenster und belastet Ihr Hauptgespräch nicht.

Eingebaute Sub-Agent-Typen

Der größte Wert von Sub-Agents: Kontextisolierung

Wenn Sie Claude bitten, Tests auszuführen, Logs zu analysieren oder viele Dateien zu durchsuchen, erzeugen diese Operationen massive Ausgaben, die Ihren Kontextfenster füllen. Verwenden Sie Sub-Agents für diese Aufgaben; die Ausgabe bleibt im Kontext des Sub-Agents, und nur eine Zusammenfassung wird an Sie zurückgegeben.

Zum Beispiel:

"Verwende einen Sub-Agent, um alle Tests auszuführen und die fehlgeschlagenen Fälle aufzulisten"

"Verwende einen Sub-Agent, um alle Dateien zu durchsuchen, die veraltete APIs verwenden"

Im Hintergrund ausführen: Strg+B

Drücken Sie Strg+B, um einen Sub-Agent in den Hintergrund zu versetzen. Sie können weiterhin mit Claude über andere Dinge chatten und werden benachrichtigt, wenn die Hintergrundaufgabe abgeschlossen ist.

Geeignet für:

• Ausführen von Testsuiten (dauert normalerweise Minuten)
• Groß angelegte Codesuchen
• Nicht dringende Code-Reviews

Benutzerdefinierte Sub-Agents

Sie können benutzerdefinierte Agents im .claude/agents/-Verzeichnis erstellen:

1---
2name: code-reviewer
3description: Code-Review-Experte. Wird automatisch nach Code-Änderungen ausgelöst.
4tools: Read, Grep, Glob, Bash
5model: sonnet
6---
7
8Sie sind ein leitender Code-Reviewer. Überprüfen Sie die folgenden Dimensionen:
9- Code-Klarheit und Lesbarkeit
10- Vollständigkeit der Fehlerbehandlung
11- Offenlegung sensibler Informationen
12- Eingabevalidierung
13- Leistungsfallen

Rufen Sie es dann im Gespräch mit @"code-reviewer (agent)" auf.

5. Kontextmanagement: Der am meisten übersehene Schlüssel

Obwohl der Kontextfenster von Claude Code groß ist (bis zu 1M Token), ist er nicht unendlich, und das Kontextmanagement bestimmt direkt die Ausgabequalität.

Was ist im Kontext?

• Ihr Gesprächsverlauf
• Alle von Claude gelesenen Dateiinhalte
• Befehlsausgabe
• CLAUDE.md-Datei (wird jedes Mal geladen)
• Memory-Datei (erste 200 Zeilen)
• Geladene Skill- und MCP-Tool-Definitionen

Fünf praktische Strategien

1. /clear: Löschen, wenn eine Aufgabe erledigt ist

Beheben Sie nicht Bugs, fügen Sie Funktionen hinzu und refaktorieren Sie alles im selben Gespräch. /clear leert den Kontext, behält aber CLAUDE.md bei, wie ein kostenloser Neustart.

2. /compact: Kontext manuell komprimieren

Wenn das Gespräch lang wird, verwenden Sie /compact, um Claude automatisch vorherige Dialoge zusammenfassen und komprimieren zu lassen. Noch besser: Fügen Sie einen Fokus zur Komprimierung hinzu:

/compact focus on API changes and test results

Auf diese Weise priorisiert Claude die Beibehaltung der Inhalte, die Ihnen wichtig sind, während der Komprimierung.

3. /context: Sehen, was Ihren Kontext frisst

Geben Sie /context ein, um die aktuelle Nutzung zu sehen – welche Dateien wie viele Token belegen und wie viel Platz MCP-Tool-Definitionen einnehmen. Ich finde oft unnütze MCP-Server, die massiv Platz verbrauchen.

4. Sub-Agents zur Isolierung von Rauschen verwenden

Das Ausführen von Tests und Analysieren von Logs erzeugt viele Ausgaben. Lassen Sie Sub-Agents das machen, um den Hauptgesprächskontext sauber zu halten.

5. Komprimierungserhaltungsanweisungen in CLAUDE.md schreiben

Sie können Claude mitteilen, was während der Komprimierung erhalten bleiben muss:

1# Komprimierungsanweisungen
2Beim Komprimieren des Kontexts immer behalten:
3- Vollständige Liste der geänderten Dateien
4- Testbefehle und -ergebnisse
5- Wichtige Architekturentscheidungen

Memory vs. CLAUDE.md

Wofür Memory da ist: Ihre Vorlieben ("diese Person mag präzise Antworten"), Projektkonventionen ("Deployment hat einen speziellen Schritt"), historische Entscheidungen ("wir haben letztes Mal Option A wegen X gewählt").

Wofür Memory NICHT da ist: Code-Details, Git-Verlauf, temporäre Zustände – diese werden genauer aus Code und Git abgerufen.

Verwenden Sie den Befehl /memory, um alle geladenen Memory anzuzeigen und zu verwalten.

6. Berechtigungsmanagement: Balance zwischen Sicherheit und Effizienz

Claude Code bietet fünf Berechtigungsmodi, die im Gespräch mit Shift+Tab durchgeschaltet werden:

Berechtigungsregelkonfiguration

In .claude/settings.json können Sie die Berechtigungen für jedes Tool fein steuern:

1{
2  "permissions": {
3    "allow": [
4      "Bash(npm run *)",
5      "Bash(git commit *)",
6      "Edit(src/**/*.ts)",
7      "Read(*.md)"
8    ],
9    "deny": [
10      "Bash(rm -rf *)",
11      "Edit(.env)"
12    ]
13  }
14}

Regelpriorität: deny → ask → allow (deny hat die höchste Priorität).

Das bedeutet, Sie können gängige Befehle mutig erlauben, während Sie mit deny sensible Dateien schützen. Zum Beispiel sollten .env-Dateien niemals bearbeitet werden.

Hierarchie der Einstellungsdateien

Ähnlich wie CLAUDE.md haben Einstellungen mehrere Ebenen:

1Organisationsrichtlinie (Höchste Priorität)
2  ↓
3CLI-Argumente
4  ↓
5.claude/settings.local.json (Lokal, nicht in Git committet)
6  ↓
7.claude/settings.json (Projektebene, mit Team geteilt)
8  ↓
9~/.claude/settings.json (Global, persönlich)
10  ↓
11Standardwerte (Niedrigste Priorität)

Mein Rat: Team-geteilte Regeln in .claude/settings.json, persönliche Vorlieben in ~/.claude/settings.json und sensible Konfigurationen in .claude/settings.local.json (denken Sie daran, zu .gitignore hinzuzufügen).

7. HOOKS: Regeln in eiserne Gesetze verwandeln

Anweisungen in CLAUDE.md sind "Vorschläge" – Claude befolgt sie meistens, vergisst sie aber gelegentlich. Hooks sind "eiserne Gesetze" – sie werden ausgeführt, egal was passiert.

Hooks sind Shell-Befehle, die automatisch durch bestimmte Lebenszyklus-Ereignisse ausgelöst werden, konfiguriert in settings.json.

Wichtige Ereignistypen

Praktische Beispiele

Auto-Formatierung – Prettier nach jeder Bearbeitung ausführen:

1{
2  "hooks": {
3    "PostToolUse": [{
4      "matcher": "Edit|Write",
5      "hooks": [{
6        "type": "command",
7        "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write"
8      }]
9    }]
10  }
11}

Schützen kritischer Dateien – Verhindern der Änderung von Produktionskonfigurationen:

1{
2  "hooks": {
3    "PreToolUse": [{
4      "matcher": "Edit|Write",
5      "hooks": [{
6        "type": "command",
7        "command": ".claude/hooks/protect-files.sh"
8      }]
9    }]
10  }
11}

Ein Hook-Befehl, der den Exit-Code 0 zurückgibt, bedeutet erlaubt; Exit-Code 2 bedeutet blockiert. Das bedeutet, Sie können jede komplexe Logik schreiben.

Erneutes Einfügen wichtiger Informationen nach Kontextkomprimierung:

1{
2  "hooks": {
3    "SessionStart": [{
4      "matcher": "compact",
5      "hooks": [{
6        "type": "command",
7        "command": "echo 'Verwende Bun, nicht npm. Führe bun test vor dem Committen aus.'"
8      }]
9    }]
10  }
11}

Dies löst ein häufiges Problem: Wenn ein langes Gespräch komprimiert wird, könnten zuvor erwähnte wichtige Anweisungen verloren gehen. Hooks können sie nach jeder Komprimierung automatisch wieder einfügen.

Vier Arten von Hooks

8. GIT-WORKFLOW: WORKTREE sinnvoll nutzen

Claude Code kann Git-Befehle ausführen, was ein zweischneidiges Schwert ist. Aber das offizielle Tool bietet ein großartiges Sicherheitsnetz: Worktree.

Git Worktree: Isolierte Arbeitsbereiche

1# Claude in einem isolierten Worktree starten
2claude --worktree feature-auth
3claude --worktree bugfix-123
4
5# Automatisch einen Namen generieren
6claude --worktree

Worktree erstellt eine unabhängige Git-Branch-Kopie unter .claude/worktrees/. Was Claude darin tut, hat keine Auswirkungen auf Ihren Hauptbranch. Beim Beenden:

• Wenn keine Änderungen → Automatische Bereinigung
• Wenn Änderungen vorhanden → Fordert Sie auf, sie zu behalten oder zu löschen

Dies ist besonders nützlich für explorative Aufgaben. Nicht sicher, ob ein Refactoring-Plan funktioniert? Probieren Sie es in einem Worktree aus; wenn es fehlschlägt, werfen Sie es ohne Risiko weg.

Ein paar eiserne Git-Gesetze

1. Lassen Sie Claude Code niemals automatisch pushen

Es kann committen, aber die Push-Aktion sollte von Ihnen bestätigt werden. Einmal auf Remote gepusht, steigen die Kosten für einen Rollback erheblich.

2. Häufig committen

Committen Sie nach Abschluss einer kleinen Funktion. Verwenden Sie /rewind, um zu jedem Checkpoint zurückzukehren, vorausgesetzt, Sie haben Commit-Aufzeichnungen.

3. Vorsicht vor destruktiven Operationen

Wenn Claude Code git reset --hard, git push --force oder rm -rf ausführen möchte, denken Sie über die Konsequenzen nach, bevor Sie zustimmen. Diese Operationen sind nicht rückgängig zu machen. Sie können diese Befehle auch in den Berechtigungsregeln verbieten.

4. Kontext aus einem PR wiederherstellen

Dies lädt PR-Änderungen und Diskussionen automatisch als Kontext, perfekt für Code-Reviews oder die Fortsetzung der Arbeit eines anderen.

1claude --from-pr 123

9. Tastenkombinationen und Befehlsreferenz

Ich verwende diese Tastenkombinationen täglich; ich empfehle dringend, sie sich einzuprägen:

Häufigste Tastenkombinationen

Häufigste Slash-Befehle

1/compact [focus]     # Kontext komprimieren, kann Fokus angeben
2/clear              # Gespräch löschen, neu beginnen
3/context            # Kontextnutzung anzeigen
4/memory             # Memory anzeigen und verwalten
5/rewind             # Zu einem Checkpoint zurückkehren
6/resume [name]       # Ein vorheriges Gespräch fortsetzen
7/model              # Modelle wechseln
8/effort [level]       # Argumentationstiefe einstellen: low/medium/high/max
9/init               # CLAUDE.md automatisch generieren
10/mcp                # MCP-Server verwalten
11/permissions        # Berechtigungsregeln anzeigen
12/cost               # Token-Verbrauch anzeigen

/init ist besonders nützlich für neue Projekte – es analysiert automatisch Ihre Codebasis und hilft, einen Entwurf der CLAUDE.md zu generieren. Obwohl es normalerweise manuelle Anpassungen erfordert, ist es viel schneller, als bei Null anzufangen.

10. EXTENDED THINKING: Claude tiefer denken lassen

Für komplexe Probleme können Sie den Extended Thinking-Modus aktivieren, der Claude mehr Zeit zum Nachdenken gibt, bevor er antwortet.

Wie man es verwendet

1# Tastenkombination umschalten
2Option+T (Mac) / Alt+T (Windows/Linux)
3
4# Oder über Befehl
5/effort high    # Tiefere Argumentation
6/effort max     # Maximale Argumentationstiefe
7/effort low     # Einfache Aufgaben, spart Token

Wann man es verwendet

• Komplexe Architekturentscheidungen
• Kniffliges Debugging (mehrere mögliche Ursachen, die ausgeschlossen werden müssen)
• Mehrstufiges Refactoring-Design
• Abwägen von Vor- und Nachteilen mehrerer Lösungen

Wann Sie es nicht benötigen

• Einfache Code-Änderungen
• Formatierung, Umbenennung
• Bereits klare Bug-Behebungen

Pro-Tipp: Das Schreiben von "ultrathink" im Prompt kann die höchste Argumentationstiefe erzwingen, ohne die effort-Einstellungen manuell anpassen zu müssen.

11. MCP-SERVER: Claude mit der Außenwelt verbinden

MCP (Model Context Protocol) ermöglicht Claude Code die Kommunikation mit externen Tools – GitHub, Datenbanken, Slack, Notion usw.

Schnell hinzufügen

1claude mcp add github -- npx @anthropic-ai/mcp-server-github
2claude mcp add postgres -- npx @anthropic-ai/mcp-server-postgres postgresql://localhost:5432/mydb

Konfigurationsdatei

MCP wird in .mcp.json konfiguriert:

1{
2  "mcpServers": {
3    "github": {
4      "type": "stdio",
5      "command": "npx",
6      "args": ["@modelcontextprotocol/server-github"],
7      "env": {
8        "GITHUB_TOKEN": "$GITHUB_TOKEN"
9      }
10    }
11  }
12}

Hinweis zum Kontext-Overhead

Jeder MCP-Server verbraucht zusätzliche 100-500+ Token für Tool-Definitionen. Verwenden Sie den Befehl /mcp, um den Overhead jedes Servers zu überprüfen und nicht verwendete zu deaktivieren.

Meine Erfahrung: Seien Sie nicht gierig. 2-3 häufig verwendete MCP-Server sind genug. Zu viele zu installieren frisst Kontextplatz mit Tool-Definitionen, was tatsächlich die Code-Analysequalität verschlechtern kann.

12. IDE-INTEGRATION: Mehr als nur ein Terminal

VS Code

Nach der Installation der Claude Code-Erweiterung können Sie Claude direkt in VS Code verwenden, ohne zum Terminal wechseln zu müssen.

Nützliche Funktionen:

• Side-by-Side-Diff-Ansicht: Claudes Änderungen werden als Diffs angezeigt, auf einen Blick klar
• Option+K / Alt+K: Schnelles Einfügen von @-Verweisen auf die aktuelle Datei
• Multi-Tab-Gespräche: Mehrere unabhängige Gespräche in verschiedenen Tabs öffnen
• Cmd+Shift+Esc: Schnell einen neuen Gesprächs-Tab öffnen

JetBrains

IntelliJ, PyCharm, WebStorm und andere JetBrains-IDEs haben auch ein Claude Code-Plugin. Suchen Sie einfach im Plugins-Marktplatz nach "Claude Code", um es zu installieren.

13. CODE-REVIEW: Vertrauen, aber prüfen

Die Code-Qualität von Claude Code ist im Allgemeinen gut, aber Sie sollten ihm nicht blind vertrauen.

Häufige Probleme

1. Over-Engineering

Sie bitten um eine einfache Utility-Funktion, und es liefert eine vollständige Abstraktionsebene mit Generics, Interfaces und Factory-Mustern. Mit Kanonen auf Spatzen schießen.

Lösung: Schreiben Sie "einfache Lösungen priorisieren" in CLAUDE.md, oder sagen Sie explizit "keine Abstraktion erforderlich" in der Anweisung.

2. Halluzinierte APIs

Es verwendet manchmal nicht existierende APIs oder veraltete Syntax, besonders für neue Versionen von Nischenbibliotheken.

Lösung: Tests ausführen. Deshalb sollten Anweisungen Validierungsstandards enthalten.

3. Scope Creep

Sie bitten es, eine Funktion zu ändern, und es refaktoriert die gesamte Datei.

Lösung: Sagen Sie explizit "ändere nur X, fasse anderen Code nicht an." Oder verwenden Sie den Befehl /freeze, um den Bearbeitungsbereich auf bestimmte Verzeichnisse zu beschränken.

Writer/Reviewer-Modus

Ein fortgeschrittener Modus, der offiziell empfohlen wird: Verwenden Sie zwei unabhängige Sitzungen, die die Rollen von "Writer" und "Reviewer" spielen.

Zwei Sitzungen haben unabhängige Kontexte; der Reviewer wird nicht von der Logik des Writers beeinflusst und kann blinde Flecken finden.

1Sitzung A (Writer): "Implementiere API-Rate-Limiting-Middleware"
2Sitzung B (Reviewer): "Überprüfe die Rate-Limiting-Implementierung in @src/middleware/rateLimiter.ts, 
3                     konzentriere dich auf Randfälle, Race Conditions und Konsistenz"
4Sitzung A: "Behebe Review-Feedback: [Füge B's Ausgabe ein]"

14. Was man mit Claude Code NICHT tun sollte

Nachdem ich so viel über "was zu tun ist" gesagt habe, sprechen wir über "was nicht zu tun ist."

1. Lassen Sie es keine Dinge tun, die Sie überhaupt nicht verstehen

Wenn Sie nichts über Kubernetes wissen, lassen Sie Claude Code keine Deployment-Konfigurationen schreiben, die Sie direkt verwenden. Sie können nicht überprüfen, was Sie nicht verstehen.

2. Verwenden Sie es nicht in Umgebungen ohne Versionskontrolle

Kein Git bedeutet keine Möglichkeit zum Rollback. Claudes Code-Änderungen könnten Ihre Dateien überschreiben; die Verwendung ohne Versionskontrolle ist wie Seiltanzen ohne Netz.

3. Werfen Sie keine riesige Aufgabe auf einmal darauf

"Migriere das gesamte Projekt von JavaScript zu TypeScript"

Diese Anweisung gibt Claude Code freie Hand, was das Ergebnis unkontrollierbar macht. Teilen Sie es in kleine Schritte auf und bestätigen Sie jeden Schritt, bevor Sie zum nächsten übergehen.

4. Erwarten Sie keine Perfektion beim ersten Versuch

Iteration ist normal. Verwenden Sie /rewind, um zurückzugehen, und verwenden Sie präzises Feedback, um zu beschreiben, "was falsch ist."

Zusammenfassung

Die Kernphilosophie der Verwendung von Claude Code ist einfach:

Es ist ein äußerst fähiger Mitarbeiter, aber kein Autopilot. Das Steuer liegt immer in Ihren Händen.

Nach Wichtigkeit geordnet, lautet mein Rat:

1. Schreibe CLAUDE.md gut — Einmal investieren, bei jedem Gespräch profitieren
2. Gib präzise Anweisungen — Ziel + Einschränkungen + Validierungsstandards
3. Nutze den Plan-Modus — Erst planen, dann handeln bei komplexen Aufgaben
4. Verwalte den Kontext — /clear, /compact, Sub-Agenten
5. Kontrolliere Berechtigungen — Gefährliche Operationen verweigern, gängige Befehle erlauben
6. Commite häufig — Behalte die Möglichkeit, Änderungen rückgängig zu machen

Wenn du dies tust, kann Claude Code deine Effizienz um ein Vielfaches steigern. Wenn du es nicht tust, wird es dir nur helfen, schneller Chaos zu erzeugen.

Der Wert eines Werkzeugs hängt immer von der Person ab, die es nutzt.

Das Obige ist eine Kombination aus der offiziellen Claude Code-Dokumentation und praktischer Erfahrung. Wenn du bessere Praktiken hast, teile sie gerne.