## Plan-Modus: Umfassender Leitfaden Haben Sie diese Erfahrung schon einmal gemacht: Sie haben Claude Code gebeten, Code für Sie zu ändern, und es hat voll losgelegt, ein Dutzend Dateien umgeschrieben – nur um festzustellen, dass es in die falsche Richtung lief? Oder Sie haben mitten in der Änderung bemerkt, dass Sie eine Abhängigkeit übersehen haben, und mussten alles rückgängig machen? Der Plan-Modus wurde genau für solche Situationen geschaffen. Er lässt Claude zunächst einen detaillierten Ausführungsplan erstellen und erst nach Ihrer Prüfung und Genehmigung mit der Arbeit beginnen — das verwandelt „erst schießen, dann die Zielscheibe malen“ in „gründlich planen, bevor man handelt“. ## Was ist der Plan-Modus? ### Plan-Modus vs. Standardmodus Im Standardmodus denkt und handelt Claude Code gleichzeitig: Code analysieren, Dateien bearbeiten, Befehle ausführen — diese Aktionen wechseln sich ab. Für einfache Aufgaben ist das sehr effizient, bei komplexen Aufgaben kann es jedoch zu einem „Schritt für Schritt“-Vorgehen führen. Der Plan-Modus ist völlig anders: | Funktion | Standardmodus | Plan-Modus | |---------|-------------|-----------| | Ausführung | Gleichzeitiges Denken und Ausführen | Erst planen, nach Genehmigung ausführen | | Dateioperationen | Liest und schreibt Dateien sofort | **Nur lesend**, nur Analyse und Suche | | Befehlsausführung | Kann Befehle direkt ausführen | Führt keine Änderungen bewirkenden Befehle aus | | Geeignet für | Einfache Bearbeitungen, schnelle Fixes | Refactoring über mehrere Dateien, Entwicklung komplexer Funktionen | | Risikokontrolle | Stützt sich auf Berechtigungssystem | Null Risiko während der Planungsphase | Vereinfacht gesagt, ist Claude im Plan-Modus wie ein Architekt mit nur einem Notizbuch — es wird das Gelände sorgfältig vermessen (Code lesen, Dateien durchsuchen), detaillierte Baupläne zeichnen (Ausführungsplan), aber keinen einzigen Stein setzen. ### Warum erst planen, dann ausführen? Die Vorteile des Planens vor der Ausführung gehen weit über „Sicherheit“ hinaus: 1. **Globale Perspektive**: Claude scannt zunächst alle relevanten Dateien und baut ein Gesamtverständnis auf, anstatt mitten in der Arbeit Lücken zu entdecken 2. **Überprüfbare Pläne**: Sie können den Plan vor der Ausführung prüfen, potenzielle Probleme erkennen und Feedback geben 3. **Weniger Nacharbeit**: Abhängigkeitskonflikte und Inkonsistenzen bei Schnittstellen lassen sich bereits in der Planungsphase identifizieren 4. **Wissensabgleich**: Durch das Lesen des Plans können Sie überprüfen, ob Claudes Verständnis des Projekts korrekt ist 5. **Wiederverwendbar**: Gute Pläne lassen sich als Vorlagen für ähnliche Aufgaben speichern ### Wann den Plan-Modus verwenden? **Für den Plan-Modus dringend empfohlen:** - Änderungen an mehr als 5 Dateien - Anpassung von Kernmodulen oder öffentlichen Schnittstellen - Neue Funktionen hinzufügen (insbesondere mit Datenbanken, APIs usw.) - Refactoring der bestehenden Code-Struktur - Bugs beheben, deren Ursache unbekannt ist (erst Investigation nötig) - Sie kennen das Projekt noch nicht gut und benötigen zuerst eine Strukturerklärung durch Claude **Standardmodus kann direkt verwendet werden:** - Einen bestimmten kleinen Bug beheben - Lokalen Inhalt in einer einzelnen Datei ändern - Kommentare oder Dokumentation ergänzen - Einfache Formatierung oder Umbenennung ## So verwenden Sie den Plan-Modus ### Modus mit Shift+Tab wechseln Den Plan-Modus zu starten ist ganz einfach. Drücken Sie im Eingabefeld von Claude Code `Shift+Tab`, um durch die Modi zu wechseln: ``` default → acceptEdits → plan → bypassPermissions → default → ... ``` Wenn links neben dem Eingabefeld **plan** als Modus angezeigt wird, haben Sie den Plan-Modus aktiviert. Sie können Ihre Absicht auch direkt im Prompt äußern: ``` Please help me create a plan first, don't modify the code directly. I want to add email verification to the user system. ``` > **Tipp**: Drücken Sie `Escape`, um jederzeit zum Standardmodus zurückzukehren. ### Claudes Verhalten im Plan-Modus Nachdem Sie den Plan-Modus aktiviert haben, sind Claudes Fähigkeiten eingeschränkt: **Möglich:** - Jede Datei lesen - Code durchsuchen (Grep, Glob) - Projektstruktur analysieren - Git-Verlauf einsehen - Web-Informationen suchen - Detaillierte Ausführungspläne erstellen **Nicht möglich:** - Dateien erstellen oder ändern - Befehle ausführen, die Seiteneffekte haben können - Abhängigkeitspakete installieren - Builds oder Tests ausführen Das bedeutet, dass Sie Claude im Plan-Modus sicher jeden Code erkunden lassen können, ohne dass es versehentlich „ausrutscht“ und etwas verändert. ### Pläne anzeigen und bearbeiten Von Claude erstellte Pläne enthalten typischerweise folgende Struktur: ```markdown ## Execution Plan: Add Email Verification Feature ### Goal Add email verification to the user registration flow. ### Impact Analysis - Files to modify: 6 - Files to create: 3 - Database changes: 1 new table needed - Risk points: Existing users are not affected, but migration scripts are needed ### Execution Steps **Phase 1: Database Layer** 1. Create migration script for `email_verifications` table 2. Modify `users` table, add `email_verified` field **Phase 2: Backend Logic** 3. Create new `email_verification_service.py` 4. Modify `auth_router.py`, add verification-related endpoints 5. Modify `user_service.py`, trigger verification email in registration flow **Phase 3: Frontend Adaptation** 6. Modify registration page, add verification prompts 7. Create new email verification page 8. Modify routing configuration ### Risks and Notes - SMTP configuration must be prepared in advance - Need to consider expiration time for verification links - Existing users should skip verification ``` Sie können Feedback zum Plan geben: ``` The plan looks good overall, but I have a few adjustments: 1. No need to create a new verification page, just use the existing toast notification 2. Set verification link expiration to 24 hours 3. Don't modify the users table in phase 1, use the status in email_verifications table instead Please update the plan. ``` Claude passt den Plan basierend auf Ihrem Feedback an, bis Sie zufrieden sind. ### Plan genehmigen und Ausführung starten Nachdem Sie den Plan bestätigt haben, wechseln Sie zurück zum Standardmodus (Drücken von `Shift+Tab`) und fordern Claude auf, den Plan auszuführen: ``` The plan looks good, please start executing according to the plan. Start with phase one. ``` Sie können auch eine phasenweise Ausführung wählen: ``` Execute phase one (database layer) first, then stop and let me verify. ``` ## Plan-Modus – Praxistutorial ### Beispiel 1: Benutzerauthentifizierung zu einem bestehenden Projekt hinzufügen Angenommen, Sie haben ein FastAPI-Projekt ohne Authentifizierungsmechanismus und müssen eine JWT-Authentifizierung ergänzen. **Schritt 1: In den Plan-Modus wechseln und Anforderungen beschreiben** ``` My FastAPI project has no user authentication currently. Please help me create a plan to add a JWT-based user authentication system. Requirements: - User registration and login - JWT token issuance and verification - Route protection (some endpoints require login) - Use SQLAlchemy to manage user table Please analyze the existing code structure first, then create a detailed execution plan. ``` **Schritt 2: Claude analysiert das Projekt und erstellt einen Plan** Claude scannt zunächst Ihre Projektstruktur: ``` I have analyzed your project structure. Here are my findings and execution plan: ## Current Project Analysis - Framework: FastAPI 0.115.x - Database: Existing SQLAlchemy configuration (database.py), using PostgreSQL - Existing models: Product, Order (in models/ directory) - Routers: product_router.py, order_router.py (both without authentication protection) - Dependency management: Using requirements.txt ## Execution Plan ### Phase 1: Infrastructure (2 files) 1. Add python-jose[cryptography], passlib[bcrypt] to requirements.txt 2. Add JWT-related configuration items to config.py (SECRET_KEY, ALGORITHM, TOKEN_EXPIRE) ### Phase 2: User Model and Database (2 files) 3. Create new models/user.py — User model 4. Create new alembic migration script ### Phase 3: Authentication Logic (3 files) 5. Create new services/auth_service.py — password hashing, JWT issuance/verification 6. Create new schemas/auth.py — request/response models 7. Create new routers/auth_router.py — /register, /login, /me endpoints ### Phase 4: Route Protection (3 files) 8. Create new dependencies/auth.py — get_current_user dependency 9. Modify product_router.py — write operations require authentication 10. Modify order_router.py — all operations require authentication ### Risk Notes - SECRET_KEY in config.py must use environment variables, cannot be hardcoded - Existing API clients need to adapt to authentication headers - Recommend verifying in test environment first ``` **Schritt 3: Überprüfung und Ausführung** ``` The plan is good. Two adjustments: 1. Don't use alembic, use SQLAlchemy's create_all directly 2. Read operations on product_router don't need authentication, only create and delete need it Everything else looks fine, please execute the plan. ``` ### Beispiel 2: Ein großes Modul refaktorieren Angenommen, in Ihrem Projekt gibt es eine `utils.py`-Datei mit 3000 Zeilen, die aufgeteilt und refactored werden muss. **In den Plan-Modus wechseln:** ``` utils.py has ballooned to 3000 lines with everything mixed in. Please help me analyze this file and create a refactoring plan to split it into multiple modules with clear responsibilities. Requirements: 1. Analyze the responsibilities of all functions in utils.py 2. Design a new module structure 3. List all files that import utils.py and their affected imports 4. Ensure all existing functionality remains unaffected after refactoring ``` Claude erstellt einen Plan wie diesen: ``` ## utils.py Refactoring Plan ### Current State Analysis utils.py contains 47 functions, which can be categorized into 5 types based on their responsibilities: | Category | Function Count | Example Functions | |----------|---------------|-------------------| | String processing | 12 | slugify, truncate, sanitize_html | | Date and time | 8 | parse_date, format_datetime, get_timezone | | File operations | 9 | read_file, ensure_dir, get_file_hash | | Data validation | 11 | validate_email, validate_phone, check_url | | HTTP utilities | 7 | retry_request, parse_response, build_url | ### Import Analysis A total of 23 files import utils.py, detailed list as follows: (List each file and the specific functions used...) ### New Module Structure utils/ ├── __init__.py # Re-exports for backward compatibility ├── strings.py # String processing ├── datetime.py # Date and time ├── files.py # File operations ├── validators.py # Data validation └── http.py # HTTP utilities ### Execution Steps (List step by step...) ### Backward Compatibility Strategy Keep all original exports in utils/__init__.py: from .strings import * from .datetime import * ... This way, undiscovered references won't break. ``` ### Beispiel 3: Bugs über mehrere Dateien hinweg beheben Nutzer berichten, dass „Bestellbeträge gelegentlich falsch berechnet werden“, aber Sie sind sich nicht sicher, wo das Problem liegt. **In den Plan-Modus wechseln:** ``` Users report that order amounts are occasionally calculated incorrectly, but not every time. Please help me investigate this issue: 1. Find all code involved in amount calculations 2. Analyze possible causes of occasional errors 3. Create a fix plan ``` Claude analysiert den Sachverhalt im Plan-Modus ausführlich: ``` ## Bug Investigation Report ### Amount Calculation Related Code After comprehensive search, code related to amount calculations is distributed across 4 files: - order_service.py:calculate_total() — main calculation logic - discount_service.py:apply_discount() — discount calculation - tax_service.py:calculate_tax() — tax calculation - cart_service.py:get_cart_total() — cart total ### Issues Found **Root cause: Floating point precision problem** In order_service.py line 127: total = sum(item.price * item.quantity for item in items) Python's floating point arithmetic has precision issues: >>> 0.1 + 0.2 0.30000000000000004 When orders contain multiple items with decimal amounts, cumulative errors may cause the final amount to be off by 1 cent. **Secondary issue: Discount calculation order** discount_service.py's discount calculation is executed after tax_service.py's tax calculation, but in some concurrent scenarios, the order may be reversed (because they are called asynchronously). ### Fix Plan 1. Change all amount calculations to use Decimal type 2. Modify the call order of discount and tax to be synchronous and sequential 3. Add unit tests for amount consistency ``` Dieses Beispiel zeigt den Wert des Plan-Modus bei der Fehlersuche – Claude stürzt sich nicht vorschnell auf Codeänderungen, sondern führt zunächst eine gründliche Analyse durch. ## Best Practices für den Plan-Modus ### 1. Beschreiben Sie das „Warum“ statt des „Wie“ **Nicht empfohlen:** ``` Please add a verify_email method to user.py that accepts a token parameter, queries the email_verifications table, and if the token matches and hasn't expired, sets user.email_verified to True. ``` **Empfohlen:** ``` We need to allow users to verify their email addresses. Users will receive an email with a verification link after registration. After clicking the link, their email status becomes verified. Please help me plan the implementation. ``` Warum? Wenn Sie das „Warum“ beschreiben, hat Claude mehr Spielraum, um die optimale Lösung zu entwerfen. Möglicherweise entdeckt Claude Randfälle, an die Sie nicht gedacht haben, oder schlägt eine elegantere Implementierung vor. Wenn Sie die genauen Implementierungsdetails vorgeben, wird der Nutzen des Plan-Modus erheblich reduziert. ### 2. Bitten Sie Claude, Risikopunkte im Plan zu identifizieren Fordern Sie Claude aktiv dazu auf, Risiken zu analysieren: ``` Please pay special attention to the following in the plan: 1. What existing functionality might this modification break? 2. Are there configuration files that need to be modified together? 3. Do database changes require migration scripts? 4. Are there any concurrency safety concerns? ``` ### 3. Führen Sie komplexe Pläne phasenweise aus Bei großen Aufgaben sollten Sie den gesamten Plan nicht auf einmal ausführen. Teilen Sie ihn in unabhängig verifizierbare Phasen auf: ``` This plan has 4 phases, please execute as follows: - Stop after completing each phase - Report the completion status of that phase - Wait for my confirmation before continuing to the next phase ``` Der Vorteil dieses Vorgehens: Wenn in einer Phase etwas schiefgeht, können Sie es rechtzeitig korrigieren, ohne eine große Anzahl von Änderungen zurückrollen zu müssen. ### 4. Kombinieren Sie Pläne mit Git-Branches Der optimale Workflow ist: **Plan-Modus erstellt Plan → Neuen Branch anlegen → Auf neuem Branch ausführen → Code-Review → Merge** ``` # Create plan in Plan mode first (Switch to Plan mode, describe requirements, review plan) # After satisfied, switch back to default mode Please create a new branch feature/email-verification first, then execute the plan. ``` Wenn Sie während der Ausführung feststellen, dass der Plan falsch ist, können Sie jederzeit zum Main-Branch zurückkehren und von vorn beginnen. ## Plan-Modus vs. direktes Coden ### Wann der Plan-Modus nicht benötigt wird - Einfache Aufgaben, die ein oder zwei Dateien betreffen - Klar bekannt ist, was und wie geändert werden soll - Nicht-funktionale Änderungen wie das Hinzufügen von Kommentaren oder das Ändern von Texten - Befehle ausführen (wie Abhängigkeiten installieren, Tests ausführen) ### Wann der Plan-Modus erforderlich ist - Änderungen, die mehr als 5 Dateien betreffen - Modifikation öffentlicher Schnittstellen oder Kernmodule - Die Projektstruktur noch nicht hinreichend vertraut ist - Die Ursache eines unbekannten Bugs erst ermittelt werden muss - Abwägungen zwischen mehreren Lösungsansätzen erforderlich sind ### Entscheidungshilfe ``` What is your task? │ ├─ Simple modification (1-2 files, clear direction) │ → Default mode, start directly │ ├─ Medium task (3-5 files, clear logic) │ → Can use Plan mode first for quick scan, then switch to execute │ └─ Complex task (multiple files, uncertain solutions, high risk) → Must use Plan mode, plan in detail before executing ``` ## Erweiterte Tipps ### 1. Plan-Vorlagen über CLAUDE.md anpassen Sie können Planungsanforderungen in der `CLAUDE.md` Ihres Projekts definieren, damit jeder Plan-Modus einem einheitlichen Format folgt: ```markdown ## Plan Mode Requirements When entering Plan mode, please generate plans according to the following template: ### Required Sections 1. **Current State Analysis**: Current code structure and relevant files 2. **Solution Design**: Specific implementation approach, including alternatives 3. **Impact Scope**: Which files will be modified, which features will be affected 4. **Risk Assessment**: Possible issues and countermeasures 5. **Execution Steps**: In sequential order, each step verifiable independently 6. **Testing Plan**: How to verify the correctness of changes ### Format Requirements - Each execution step should indicate the files involved - New files should be marked with [NEW] - Files to modify should be marked with [MODIFY] - Risk points should be marked with High/Medium/Low severity ``` Nachdem Sie dies der `CLAUDE.md` hinzugefügt haben, strukturiert Claude jeden Plan-Modus gemäß dieser Vorlage. ### 2. Sub-Agents zur Erkundung im Plan-Modus nutzen Im Plan-Modus können Sie Claude bitten, Sub-Agents (Agent-Tools) für eine tiefere Erkundung zu verwenden: ``` Before creating the plan, please help me figure out the following: 1. What does the current database schema look like? Use a sub-agent to analyze all model files 2. What is the list of existing API endpoints? Use a sub-agent to scan all router files 3. What third-party libraries does the project use? Check requirements.txt or pyproject.toml ``` Sub-Agents führen diese Erkundungsaufgaben in separaten Kontexten aus und fassen die Ergebnisse anschließend für die Hauptsession zusammen. So kann Claude genauere Pläne erstellen. ### 3. Pläne speichern und wiederverwenden Gute Pläne können als Referenzvorlagen gespeichert werden. Sie können Claude bitten, den Plan als Markdown-Datei zu exportieren: ``` Please save the plan we just created to docs/plans/add-email-verification.md. We can reference it when working on similar features in the future. ``` Wenn Sie das nächste Mal auf ähnliche Anforderungen stoßen, können Sie direkt darauf verweisen: ``` Please refer to the plan structure in docs/plans/add-email-verification.md and create a similar plan for SMS verification. ``` ### 4. Plan-Modus für Code-Reviews nutzen Der schreibgeschützte Charakter des Plan-Modus macht ihn besonders geeignet für Code-Reviews: ``` (Enter Plan mode) Please review all service files in the src/services/ directory, focusing on: 1. Is error handling comprehensive? 2. Are there any SQL injection risks? 3. Are there unclosed resources (database connections, file handles)? 4. Do async code have race conditions? Please provide a detailed review report and improvement suggestions. ``` Da der Plan-Modus keine Dateien ändert, können Sie Claude bedenkenlos den Produktionscode prüfen lassen, ohne befürchten zu müssen, dass etwas versehentlich „praktischerweise“ geändert wird. ### 5. Mit /compact lange Plan-Sessions kombinieren Der Erkundungsprozess im Plan-Modus kann viel Kontext verbrauchen (insbesondere nach der Analyse vieler Dateien). Wenn Sie das Gefühl haben, dass der Kontext knapp wird, können Sie `/compact` verwenden, nachdem der Plan erstellt wurde, aber vor der Ausführung: ``` /compact Keep the complete execution plan and impact analysis, compress the intermediate exploration process ``` Dadurch bleibt für die Ausführungsphase ausreichend Kontext-Speicherplatz. ## FAQ **Q: Kann Claude im Plan-Modus versehentlich Dateien modifizieren?** A: Nein. Der Plan-Modus untersagt alle Schreiboperationen auf Systemebene. Claude kann jede Datei lesen, aber keine Inhalte erstellen, ändern oder löschen. **Q: Kann sich Claude nach dem Erstellen eines Plans und dem Wechsel in den Default-Modus zur Ausführung noch an den Plan erinnern?** A: Ja. Solange Sie `/clear` nicht zum Löschen des Verlaufs verwendet haben, geht durch den Moduswechsel kein Kontext verloren. Der Plan befindet sich weiterhin im Gesprächsverlauf, und Claude kann den Plan direkt ausführen. **Q: Kann ich im Plan-Modus MCP-Tools verwenden?** A: Sie können schreibgeschützte MCP-Tools verwenden (wie Suche oder Dokumentationsabfragen), aber keine Tools, die Seiteneffekte erzeugen. **Q: Wenn ich den Plan nicht gut finde, kann ich Claude bitten, einen neuen Plan zu erstellen?** A: Selbstverständlich. Sie können Claude wiederholt bitten, den Plan zu ändern, bis Sie zufrieden sind. Die vollständige Risikofreiheit des Plan-Modus ermöglicht es Ihnen, frei zu experimentieren und anzupassen. **Q: Wie kann ich Pläne in der Teamzusammenarbeit teilen?** A: Sie können Claude bitten, den Plan als Markdown-Datei zu speichern und in das Git-Repository zu committen. Sie können den Planinhalt auch direkt in die PR-Beschreibung aufnehmen, um das Code-Review zu erleichtern.