Disclaimer

1   Einleitung – Was ist Claude Code?

Claude Code ist Anthropics terminalbasierter KI-Agent für Software-Entwicklung. Der entscheidende Unterschied zu einem Chat-Assistenten: Claude Code arbeitet direkt im Projekt. Es liest die Codebasis, führt Befehle aus, schreibt und bearbeitet Dateien – alles aus dem Terminal heraus.

Drei Eigenschaften machen Claude Code besonders:

• Kontext: Beim Start lädt es automatisch CLAUDE.md – eine Briefing-Datei mit Projektkontext, Konventionen und Regeln.
• Erweiterbarkeit: Wiederverwendbare Workflows lassen sich als Skills speichern und per Slash-Command aufrufen. Externe Dienste wie GitHub, Datenbanken oder Browser binden sich über MCP-Server an.
• Autonomie: Mit Auto Mode und Worktrees kann Claude Code komplette Features eigenständig bauen, testen und committen.

Diese Anleitung führt vom ersten Start bis zum vollständig konfigurierten Setup. Der Lernpfad in Kapitel 21 zeigt, wie man schrittweise vorgeht, ohne sich zu übernehmen.

2   Schnellstart in 10 Minuten

Fünf Schritte, um sofort loszulegen:

1. Installieren: Terminal öffnen und Installer starten.
   curl -fsSL https://claude.ai/install.sh | bash
   Danach Terminal neu öffnen.
2. Starten: In das Projektverzeichnis wechseln und claude eingeben. Beim ersten Start erfolgt der Browser-Login.
3. Datenschutz: Sofort nach dem Login unter claude.ai → Settings → Privacy → Help Improve Claude auf Off setzen.
4. Initialisieren: /init eingeben – Claude analysiert das Projekt und legt CLAUDE.md automatisch an.
5. Loslegen: Aufgabe formulieren, Shift+Tab für Plan Mode, Plan reviewen, dann implementieren lassen.

3   Voraussetzungen, Pläne und Modelle

3.1   Kostenpläne im Überblick

Ein bezahlter Anthropic-Account ist Pflicht – der kostenlose Claude.ai-Plan funktioniert nicht. Authentifizierung wahlweise per Subscription-Login oder per API-Key.

3.2   Modelle und Effort-Levels

Modellwechsel mit /model opus, /model sonnet oder /model haiku. Opus 4.7 unterstützt Effort-Levels mit /effort:

3.3   Nutzungslimits

Jeder Plan hat tägliche und wöchentliche Kontingente. Limits prüfen:

• /status im Terminal – zeigt Plan, Modell-Status und verbleibende Nutzung
• claude.ai/settings/usage im Browser – vollständige Aufschlüsselung aller Kontingente

4   Installation

Es gibt zwei Wege: das Terminal-CLI und die Desktop-App. Beide teilen sich Login und Konfiguration.

Terminal-Installation (empfohlen)

Kein Node.js mehr nötig – läuft direkt als Binary und aktualisiert sich automatisch:

# macOS / Linux
curl -fsSL https://claude.ai/install.sh | bash

# Windows (PowerShell)
irm https://claude.ai/install.ps1 | iex

# macOS via Homebrew (manuelles Update)
brew install claude-code

Nach der Installation:

claude --version    # Version prüfen
claude doctor       # Diagnose
claude              # Starten und Browser-Login

Desktop-App

Download unter claude.com/download. Die App bietet parallele Sessions in isolierten Git-Worktrees sowie einen Tab für lokale und Cloud-Sessions.

Updates

claude update           # Sofortiges Update
brew upgrade claude-code  # Bei Homebrew

5   Datenschutz und Sicherheit

Diese Einstellungen gehören vor die erste echte Session.

5.1   Pflicht-Setting vor der ersten Session

5.2   Was Claude überträgt

Jede Datei, die Claude liest, geht vollständig an Anthropics Server – es scannt nicht automatisch das Projekt, aber jede explizit gelesene Datei wird übertragen. Besonders sensibel:

• .env-Dateien mit API-Keys und Passwörtern
• Zertifikate (.p12, .mobileprovision) und SSH-Schlüssel
• Medizinische, juristische oder anderweitig geschützte Daten

Dateien ausschließen mit .claudeignore

Wie .gitignore verhindert .claudeignore das automatische Lesen bestimmter Dateien:

# .claudeignore
/Config/Secrets/
*.env
**/TestData/real_patients/**
/Resources/Credentials/

Verhaltensregeln in CLAUDE.md

Für regulierte Projekte empfiehlt sich ein Datenschutz-Block in der CLAUDE.md:

# Datenschutz
NIEMALS lesen:
- /TestData/ (Patientendaten)
- Dateien mit "patient", "versicherte" oder "KV-Nummer" im Namen
- /Config/Live/*.json (Produktionskonfiguration)

Einsatz in regulierten Umgebungen

Claude Code verarbeitet Anfragen auf US-Servern (AWS). Für DSGVO- und SGB-V-relevante Gesundheitsdaten:

5.3   Wie Claude Code dich schützt

• Read-only by default: Fragt vor jedem Edit und jedem Bash-Befehl nach.
• Schreibgrenze: Nur Startverzeichnis und Unterordner – deshalb immer im Projektroot starten.
• Command-Blocklist: curl und wget sind standardmäßig gesperrt.
• Prompt-Injection-Schutz: Web-Fetch-Inhalte werden so behandelt, dass eingeschleuste Anweisungen nicht automatisch zu Tool-Calls führen.

6   Erste Schritte und tägliche Befehle

6.1   Im Projekt starten

cd mein-projekt
claude

Beim ersten Start: Theme wählen, Browser-Login, claude doctor zur Verifikation. Danach /init eingeben – das generiert eine CLAUDE.md mit Projektkontext, Build-Befehlen und Konventionen. Diese Datei wird bei jeder weiteren Session automatisch geladen.

6.2   Die wichtigsten Slash-Commands

Session-Management

claude -c            # Letzte Session fortsetzen
claude -r "name"     # Session per Name fortsetzen
@datei.swift         # Datei in den Kontext laden
@Sources/Views/      # Ordner in den Kontext laden

6.3   Modi

Shift+Tab wechselt zwischen den Modi:

• Normal: Fragt vor jeder Aktion nach.
• Auto-Accept: Aktionen ohne Rückfrage, sofern nicht durch Deny gesperrt. Für lange Sessions in einem gepushten Branch.
• Plan Mode: Read-only – Claude erstellt nur einen Plan. Ideal für den Analyze-Plan-Build-Workflow.
• Auto Mode (Max-Plan): Claude trifft Entscheidungen vollständig selbstständig. Nicht für Production-Deploys.

7   CLAUDE.md – Das Projektgedächtnis

CLAUDE.md ist die wichtigste Datei im Setup. Sie wird bei jeder Session automatisch geladen und gibt Claude den Kontext, den er sonst jedes Mal neu erraten müsste.

7.1   Was reingehört

Vier Fragen beantworten, mehr nicht:

• Was ist das Projekt? (Stack, Plattform-Targets, Sprache)
• Wie wird es gebaut und getestet? (Build- und Test-Befehle, Tooling)
• Welche Konventionen gelten? (Code-Style, Ordnerstruktur, Architektur-Regeln)
• Was soll Claude nicht tun? (Verbote, Tabu-Bereiche)

Nicht reingehört: Tutorials, lange Erklärungen, Marketing, Dokumentationstexte. Die Datei ist eine Briefing-Karte, kein Wiki. Maximal 200 Zeilen.

7.2   Wo die Datei liegt

Inhalte werden zusammengeführt, nicht überschrieben:

• ~/.claude/CLAUDE.md – global, gilt für alle Projekte
• CLAUDE.md im Projektroot – gilt nur für dieses Projekt (ins Repo committen!)
• CLAUDE.local.md im Projektroot – persönlich, nicht im Git
• Unterordner-CLAUDE.md – wird nur geladen, wenn man dort arbeitet

7.3   Beispiel und Best Practices

Globale CLAUDE.md (~/.claude/CLAUDE.md):

# Allgemein
Antworte auf Deutsch.
Halte dich kurz.
Bei größeren Änderungen erst einen Plan vorschlagen.

# Verbote
Niemals Inhalte aus .env oder secrets/ lesen.
Kein git push --force ohne explizite Bestätigung.

Projekt-CLAUDE.md (Beispiel Swift / SwiftUI):

# Projekt
SwiftUI-App, Targets: macOS, iPadOS, iPhone

# Build
xcodebuild -scheme AppName \
  -destination "platform=iOS Simulator,name=iPhone 16"

# Navigation
- iPhone: NavigationStack
- macOS/iPadOS: NavigationSplitView

# Verbote
Keine DispatchQueue – nur async/await.

8   Die neun Bausteine im Überblick

Claude Code besteht aus neun Bausteinen, die zusammenspielen:

9   Verzeichnisstruktur und settings.json

Alle Bausteine folgen derselben Logik: global im Home-Verzeichnis, projektspezifisch im Projekt, lokal-persönlich in einer Datei, die nicht ins Git kommt.

~/.claude/                       # Globale Konfiguration
├── CLAUDE.md                    # Globale Vorlieben
├── settings.json                # Globale Permissions, Hooks, MCP
├── skills/<name>/SKILL.md       # Globale Skills
└── agents/<name>/AGENT.md       # Globale Subagents

.claude/                         # Projektspezifisch (ins Git)
├── settings.json                # Projekt-Permissions, Hooks, MCP
├── skills/<name>/SKILL.md       # Projekt-Skills
└── agents/<name>/AGENT.md       # Projekt-Subagents

CLAUDE.local.md                  # Persönlich, nicht ins Git
.claude/settings.local.json      # Lokal, nicht ins Git

Aufbau der settings.json

{
  "permissions": {
    "allow": ["Read", "Edit", "Bash(git diff*)"],
    "deny":  ["Bash(rm -rf *)", "Read(.env*)"]
  },
  "hooks": { "PostToolUse": [...] },
  "mcpServers": { "github": {...} },
  "model": "claude-opus-4-7"
}

Die drei Ebenen (global, Projekt, lokal) werden zusammengeführt. Deny gewinnt immer.

10   Permissions

Permissions steuern, was Claude ohne Rückfrage darf und was tabu ist. Eine Deny-Regel ist eine Wand.

10.1   Die drei Stufen

10.2   Regeln formulieren

Read                    # Lesezugriff allgemein
Edit                    # Datei-Edits allgemein
Read(.env*)             # Lesen von .env-Dateien
Bash(git status*)       # nur git status
Bash(git *)             # alle git-Befehle
Bash(xcodebuild *)      # alle xcodebuild-Calls

10.3   Empfohlene Konfiguration

Globale ~/.claude/settings.json – harte Verbote:

{
  "permissions": {
    "deny": [
      "Bash(rm -rf *)",  "Bash(sudo *)",
      "Bash(curl *)",    "Bash(wget *)",
      "Read(.env*)",     "Read(**/secrets/**)",
      "Read(**/.ssh/**)", "Read(**/Credentials/**)"
    ]
  }
}

Projektspezifische .claude/settings.json – Routine erlauben:

{
  "permissions": {
    "allow": [
      "Read", "Edit",
      "Bash(git status*)", "Bash(git diff*)",
      "Bash(git log*)",    "Bash(git add *)",
      "Bash(git commit *)", "Bash(xcodebuild *)",
      "Bash(swift test*)"
    ]
  }
}

11   Hooks

Hooks sind Shell-Befehle, die Claude bei bestimmten Ereignissen automatisch ausführt. Sie sind für Mechanik, nicht für Logik.

Lifecycle-Events

• PostToolUse – nach jedem Tool-Call; klassisch für Formatter und Linter
• PreToolUse – vor jedem Tool-Call; für zusätzliche Prüfungen
• Stop – am Sessionende; für Desktop-Notifications

Wichtige Variablen

$CLAUDE_FILE_PATH     # die bearbeitete Datei
$CLAUDE_TOOL_NAME     # welches Tool lief
$CLAUDE_PROJECT_DIR   # Projektroot

Beispiel – SwiftFormat nach jedem Edit

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "if [[ \"$CLAUDE_FILE_PATH\" == *.swift ]]; then swiftformat \"$CLAUDE_FILE_PATH\"; fi"
          }
        ]
      }
    ]
  }
}

Beispiel – Desktop-Notification beim Sessionende

{
  "hooks": {
    "Stop": [
      {
        "hooks": [{
          "type": "command",
          "command": "osascript -e 'display notification \"Claude fertig\" with title \"Claude Code\"'"
        }]
      }
    ]
  }
}

12   Skills

Skills sind benannte, wiederverwendbare Anweisungen, die gezielt aufgerufen werden. Sie sparen Zeit bei allem, was sich im Alltag wiederholt.

12.1   Aufbau eines Skills

--- name: new-view
description: Legt eine neue SwiftUI-View nach unseren Konventionen an
---

Erstelle eine neue SwiftUI-View. Schritte:

1. Datei unter Sources/Views/<Feature>/<Name>View.swift anlegen
2. @Observable ViewModel einbinden
3. Preview-Provider ergänzen
4. In die Navigation eintragen

Aufruf: /new-view ProfilEditor. Argumente landen als $ARGUMENTS oder $1, $2 im Skill.

12.2   Empfehlenswerte Community-Skills

13   Subagents

Subagents sind Claude-Instanzen für klar abgegrenzte Aufgaben. Sie laufen mit eigenem Kontext und geben nur eine Zusammenfassung an die Hauptsession zurück.

Aufbau – Beispiel Code-Reviewer

--- name: code-reviewer
description: Senior Code-Reviewer. Nach Code-Änderungen proaktiv aufrufen.
tools: Read, Grep, Glob, Bash(git diff*)
model: sonnet
---

Du bist Senior Code-Reviewer für ein Swift-Projekt.
Analysiere nur die geänderten Dateien.
Gib zurück: max. 5 kritische Punkte, sortiert nach Priorität.
Keine langen Erklärungen.

Drei Felder, die zählen

• description – entscheidet, ob Claude den Agent automatisch aufruft.
• tools – begrenzt, was der Agent darf. Eng halten.
• model – Recherche/Reviews: sonnet; Architekturanalyse: opus; einfache Suchen: haiku.

14   MCP-Server

MCP-Server (Model Context Protocol) sind externe Werkzeuge, die Claude aufrufen kann. Damit wird Claude zu einem Agenten, der echte Aktionen ausführt: GitHub-Issues lesen, Datenbankabfragen, Cloud-Dienste steuern.

14.1   Grundlagen und Einrichtung

claude mcp add github -- npx -y @modelcontextprotocol/server-github
claude mcp add --transport http my-api https://meine-api.de/mcp
claude mcp list
/mcp                    # Status aller Server prüfen

14.2   Der Senior-Engineer-Stack – 5 kostenlose MCPs

15   Plugins

Plugins sind vorgefertigte Pakete, die mehrere Bausteine bündeln: Skills, Hooks, Subagents, Settings, manchmal MCP-Server.

Verwaltung

/plugins
claude plugin add <name>
claude plugin list
claude plugin remove <name>
/reload-plugins

Empfehlenswerte Plugins

16   Loops und geplante Aufgaben

Loops und Tasks lassen Claude in Intervallen oder zu festen Zeiten arbeiten.

Einsatzgebiete

• Loops: Build-Status beobachten, CI-Build alle 3 Minuten prüfen, Test-Ergebnisse
• Geplante Tasks: Tägliche Release-Notes, Meeting-Vorbereitung, Wartungsaufgaben

In der Praxis

/loop 5m check ob der staging-build fertig ist und melde dich
/loop 10m /security-review
/schedule "0 8 * * 1-5" /daily-standup-prep
/loop status
/loop stop

In settings.json

{
  "scheduled_tasks": [
    {
      "name": "daily-standup",
      "schedule": "0 8 * * 1-5",
      "command": "/daily-standup-prep",
      "notify": true
    }
  ]
}

17   Token-Optimierung und Kostenkontrolle

17.1   Modellwahl und /clear

• Modellwahl: Opus kostet ca. das 5-fache von Sonnet pro Token. Opus gezielt für Architektur und Refactoring, Sonnet für den Alltag.
• /clear: Jeder Token im Kontext kostet bei jeder Anfrage erneut. Lange Sessions ohne /clear werden überproportional teuer.
• Subagents: Eigener Kontext, knappe Antwort an den Hauptchat. Hauptkontext bleibt klein.

17.2   claude-mem – Dauerhaftes Gedächtnis

Claude Code vergisst nach jeder Session den Kontext. claude-mem löst dieses Problem: Es fasst jeden Tool-Call zusammen, speichert die Beobachtungen lokal in SQLite und lädt sie bei der nächsten Session.

npx claude-mem install
# Alternativ
/plugin marketplace add thedotmack/claude-mem
/plugin install claude-mem

17.3   RTK – Token-Kompression

RTK (Rust Token Killer) ist ein CLI-Proxy, der Befehlsausgaben zusammenfasst, bevor sie Claude erreichen. Ergebnis: 60–90 % weniger Tokens.

curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/master/install.sh | sh
rtk init -g        # Hooks für Claude Code aktivieren
rtk init --show    # Status prüfen
rtk gain           # Einsparungen anzeigen

18   Cloud-Automationen mit Routines

Routines sind vollständig autonome Cloud-Automationen – ohne lokalen Server.

Routine einrichten

1. claude.ai/code/routines öffnen
2. New routine → Name vergeben
3. Prompt schreiben (so genau wie ein Auftrag an einen Mitarbeiter)
4. GitHub Repository auswählen
5. Trigger wählen: Schedule, API oder GitHub Event
6. Connectors verbinden (Gmail, Slack etc.)
7. Run now zum Testen – erst danach den Schedule aktivieren

Beispiel – Tägliche E-Mail-Zusammenfassung

Geh in meine E-Mails über den Gmail Connector.
Lies alle ungelesenen E-Mails seit gestern.
Fass jede E-Mail in einem Satz zusammen.
Sortiere nach: Dringend, Aktion nötig, Info.
Schick mir die Zusammenfassung als Slack-Nachricht.

Beispiel – PR-Review bei jedem Pull Request

Ein neuer Pull Request wurde geöffnet.
Prüfe den Code auf Sicherheitsprobleme, Performance-Probleme,
Code-Stil und Lesbarkeit.
Schreib ein Review als Kommentar auf den PR.

19   Fortgeschrittene Workflows

19.1   Paralleles Arbeiten mit Worktrees

claude --worktree mein-feature   # Worktree starten
claude -w                        # Schneller Worktree-Start

Die Desktop-App bietet einen Code-Tab mit Worktree-Checkbox – am bequemsten für 3–5 parallele Sessions.

19.2   Der Verification-Loop

Der wichtigste Einzeltipp von Boris Cherny (Claude Code-Gründer):

"If Claude has that feedback loop, it will 2–3x the quality of the output."

Wir bauen jetzt zusammen Feature X.
Bevor du eine einzige Zeile Code schreibst, definiere zuerst,
wie du selbst prüfst, ob das fertige Feature funktioniert:

1. Welcher Test, Befehl oder Browser-Check beweist, dass es geht?
2. Was ist dein Plan?
3. Erst nach Zustimmung umsetzen.

19.3   Sandbox für autonome Arbeit

/sandbox
# Oder in settings.json:
{
  "sandbox": {
    "enabled": true,
    "filesystem": {
      "writable": ["$CLAUDE_PROJECT_DIR/Sources", "$CLAUDE_PROJECT_DIR/Tests"],
      "readable": ["$CLAUDE_PROJECT_DIR"]
    },
    "network": { "enabled": false }
  }
}

19.4   Plan Mode zuerst

Für komplexe Aufgaben: Shift+Tab → plan. Claude erstellt einen Plan, den man prüft. Erst wenn der Plan überzeugt, in den Umsetzungsmodus wechseln.

20   Claude in anderen Werkzeugen

20.1   Claude for Word

Anthropic hat Claude direkt in Microsoft Word eingebunden. Änderungen erscheinen als Vorschläge mit Änderungsverfolgung.

Voraussetzungen

• Claude Team oder Enterprise (Pro auf Warteliste)
• Microsoft 365 (kein Word 2016/2019)
• Dateiformat .docx

Installation

1. marketplace.microsoft.com – Claude by Anthropic for Word suchen
2. Installieren, Word öffnen, Add-in aktivieren (Mac: Tools → Add-ins)
3. Mit Claude-Account einloggen

Wichtige Funktionen

• Texte mit Änderungsverfolgung bearbeiten (Formatierung bleibt erhalten)
• Dokument auf Unstimmigkeiten prüfen (Querverweise, Nummerierung, Begriffe)
• Fragen mit klickbaren Quellenangaben
• Vorlagen ausfüllen mit übernommener Formatierung
• Cross-App: Word + Excel + PowerPoint in einem Gespräch

20.2   OpenAI Codex als zweites Modell

Das Codex-Plugin bindet die OpenAI Codex CLI direkt in Claude Code ein. Das ermöglicht Code-Reviews durch ein zweites, unabhängiges Modell – ohne die Claude-Session zu verlassen.

KI-Modelle erkennen eigene Fehler schlechter als fremde – ein zweites Modell bringt einen frischen Blick.

Was das eigentlich ist

Die OpenAI Codex CLI ist ein eigenständiges Kommandozeilenwerkzeug von OpenAI, das ähnlich wie Claude Code funktioniert: es liest Code, analysiert ihn und gibt Feedback. Alle Reviews sind ausschließlich lesend – Codex verändert keine Dateien.

Welchen Account brauche ich?

Setup Schritt für Schritt

# Schritt 1 – Voraussetzungen prüfen
node --version    # muss 18.18 oder neuer sein

# Schritt 2 – Codex CLI installieren
npm install -g @openai/codex

# Schritt 3 – Authentifizieren
# Option A: ChatGPT-Account
codex login
# Option B: API Key
export OPENAI_API_KEY="sk-..."

# Schritt 4 – Plugin installieren
/plugin marketplace add openai/codex-plugin-cc
/plugin install codex@openai-codex
/reload-plugins

# Schritt 5 – Installation prüfen
/codex:setup

Verfügbare Commands

Wann lohnt sich das?

Das Plugin ist sinnvoll, wenn:

• Man bereits einen ChatGPT- oder OpenAI-Account hat (kein Extra-Aufwand)
• Man Code schreibt, der produktiv eingesetzt wird (Sicherheit, Korrektheit wichtig)
• Man vor einem Release noch einen unabhängigen Check will
• Man /codex:adversarial-review als letzten Prüfschritt vor einem Merge einbauen will

Das Plugin ist weniger sinnvoll, wenn:

• Man keinen OpenAI-Account hat und keinen anlegen will
• Man hauptsächlich experimentellen oder wegwerfbaren Code schreibt
• Die Claude-internen Reviews mit /ultrareview bereits ausreichen

21   Lernpfad: Von Einsteiger zu Experte

Wer alles auf einmal aufsetzt, baut Konfiguration, die er später nicht mehr versteht:

1. Schritt 1 – Erstes echtes Feature: Ein überschaubares Feature aus dem eigenen Projekt suchen. Plan Mode an, Plan prüfen, dann Auto-Accept zum Bauen, am Ende /review.
2. Schritt 2 – CLAUDE.md schärfen: Nach zwei oder drei Sessions Muster bemerken. Diese Erkenntnisse gehören rein: schrittweise, kurz, genau.
3. Schritt 3 – Permissions sauber: Globale Deny-Regeln einmal anlegen. Projektspezifische Allow-Liste aus dem Alltag wachsen lassen.
4. Schritt 4 – Hooks für Mechanik: Mit dem Formatter anfangen. SwiftFormat (oder Prettier, Black) nach jedem Edit.
5. Schritt 5 – Skills für Wiederholungen: Was dreimal im Monat gebraucht wird, wird ein Skill. Erst anlegen, wenn der Bedarf gespürt wurde.
6. Schritt 6 – Subagents für Komplexes: Wenn Sessions zu lang werden, Reviews und Recherche in Subagents auslagern.
7. Schritt 7 – MCP gezielt einsetzen: Mit GitHub anfangen, zuerst nur lesende Operationen.
8. Schritt 8 – Fortgeschrittenes Setup: Worktrees, Sandbox, Routines, RTK und claude-mem für maximale Effizienz.

22   Was Claude Code nicht ist

• Kein Ersatz für eigenes Verständnis. Wer den Code nicht versteht, den Claude produziert, baut sich technische Schulden.
• Kein Partner für streng vertrauliche Arbeit auf Consumer-Plänen. Auf Pro und Max geht jede gelesene Datei an Anthropic. Sensible Daten gehören in Team-, Enterprise- oder API-Setup.
• Kein Echtzeit-Werkzeug. Antworten brauchen ihre Zeit, gerade bei Opus. Für Live-Pair-Programming ist Claude zu langsam.
• Keine Lösung für sehr große Monorepos. Mit Repos im Multi-Millionen-Zeilen-Bereich kommt Claude ins Stocken. Selektives Laden mit @-Mentions wird Pflicht.
• Kein Ersatz für saubere Tests und CI. Claude kann Tests schreiben – laufen lassen muss sie die Pipeline.

23   Troubleshooting

24   Glossar

Zurück zur Übersicht