# Claude Code für Einsteiger: Projekte in der Praxis analysieren und bearbeiten
> Praktischer Leitfaden zur Arbeit mit Claude Code: Erforschung der Codebasis über Read, Glob und Grep, Durchführung von Code Reviews, durchgängige Dateibearbeitung und sicheres Rückgängigmachen von Änderungen.
## 1. Wie Claude Code die Codebasis erkundet und liest
Im Gegensatz zu üblichen KI-Chats im Browser, bei denen Entwickler den Quellcode manuell in das Dialogfenster kopieren müssen, ist Claude Code ein vollwertiger Terminal-Agent. Er hat direkten Zugriff auf das lokale Dateisystem Ihres Projekts und wählt eigenständig spezialisierte Tools zur Navigation durch die Codebasis aus.
Der Agent lädt nicht das gesamte Projekt gleichzeitig in den Speicher (was sofort zum Verbrauch des Token-Limits führen würde), sondern wendet eine gezielte Strategie des schrittweisen Lesens an.
```mermaid
flowchart TD
A["Запит розробника:
'Як працює авторизація?'"] --> B["Claude Code CLI"]
B --> C["Glob
(Пошук файлів auth/*, login.*)"]
B --> D["Grep
(Пошук ключових слів createSession, jwt)"]
C & D --> E["Аналіз знайдених шляхів"]
E --> F["Read
(Цільове читання знайдених файлів)"]
F --> G["Синтез відповіді з точними посиланнями"]
```
### Der grundlegende Werkzeugkasten für die Exploration
| Tool | Funktion | Typisches Anwendungsszenario |
| :--- | :--- | :--- |
| **`Read`** | Öffnet und liest eine bestimmte Datei anhand des angegebenen Pfads | `Read src/auth/login.ts`, um die Logik einer Komponente zu untersuchen |
| **`Glob`** | Findet Dateien und Pfade anhand von Masken oder Erweiterungen | Suche nach allen Konfigurationsdateien `**/*.config.{js,ts}` oder Tests `*.test.ts` |
| **`Grep`** | Führt eine Volltextsuche nach Zeichenketten oder regulären Ausdrücken durch | Suche nach Aufrufstellen einer Funktion oder `TODO`-Kommentaren im gesamten Code |
| **`Bash(ls)`** | Untersucht die Verzeichnisstruktur und vorhandene Module | Erkundung der Struktur des Ordners `src/components/` |
> [!NOTE]
> Sie müssen diese Utilities nicht manuell aufrufen. Es genügt, eine ingenieurtechnische Frage in natürlicher Sprache zu formulieren, und Claude Code startet selbstständig die optimale Kette von Tools.
---
## 2. Schnelles Onboarding in ein unbekanntes Projekt
Wenn Sie ein großes Repository zum ersten Mal öffnen, ist es ineffizient, Stunden damit zu verbringen, hunderte Dateien manuell zu lesen. Claude Code ermöglicht es Ihnen, innerhalb von Sekunden ein umfassendes architektonisches Bild zu erhalten.
### Formulierung der initialen Architekturabfrage
Navigieren Sie in das Stammverzeichnis des Repositories, starten Sie `claude` und beginnen Sie mit einer breiten diagnostischen Prompt-Anweisung:
```text
Give me an overview of this project. What does it do, what is the tech stack, and how is the code organized?
```
### Was der Agent während des Scans tut
1. **Lesen der Abhängigkeits-Manifeste:** Analysiert `package.json`, `Cargo.toml`, `go.mod` oder `requirements.txt`, um die wichtigsten Bibliotheken und Frameworks zu identifizieren.
2. **Prüfung der Dokumentation:** Öffnet `README.md`, `ARCHITECTURE.md` oder Spezifikationsdateien.
3. **Analyse der Ordnerstruktur:** Bewertet die Aufgabenteilung zwischen den Verzeichnissen (`src/api`, `src/components`, `src/services`, `prisma`).
4. **Erstellung einer Zusammenfassung:** Gibt einen strukturierten Bericht zurück, der die Schlüsselmodule, Einstiegspunkte und Startanweisungen auflistet.
> [!TIP]
> Die Erläuterungen von Claude basieren auf dem aktuellen Code auf der Festplatte, nicht auf veralteter Dokumentation, die oft jahrelang nicht aktualisiert wird.
---
## 3. Gezielte Exploration: Nachverfolgung von Datenflüssen und Requests
Nachdem Sie das Gesamtbild verstanden haben, ist es Zeit, spezifische Geschäftsszenarien zu untersuchen. Der größte Vorteil von Claude Code gegenüber herkömmlichen Modellen ist die Fähigkeit, die vollständige Call Trace über verschiedene Ebenen der Anwendung hinweg nachzuverfolgen.
:::tabs
@tab Authentifizierung
```text
How does authentication work in this project? Trace the lifecycle of a request from the login form submission through JWT validation to the protected database query.
```
@tab Bestellabschluss
```text
What happens when a user submits the checkout form? Trace the request flow from the frontend form to payment gateway processing and email notification dispatch.
```
@tab Event-Verarbeitung (Webhooks)
```text
Trace how incoming Stripe webhooks are received, verified for signature integrity, and processed in our database transaction worker.
```
:::
### Wie Claude Interaktionsketten nachverfolgt
Wenn Sie eine Aufgabe im Format „Trace the flow“ stellen, führt der Agent folgende Schritte aus:
- Findet den UI-Komponenten des Formulars über `Grep`.
- Findet die Klick-Handler-Funktion und bestimmt den entsprechenden API-Endpoint.
- Öffnet den Backend-Router und analysiert die angewendeten Middleware-Schichten.
- Untersucht ORM-/Datenbankaufrufe und gibt ein kohärentes, schrittweises Schema mit Zeilennummern zurück.
---
## 4. Tiefensuche nach Mustern und Refactoring von Imports
Dank der integrierten Tools `Grep` und `Glob` führt der Agent präzise Suchen nach der Verwendung von Funktionen, Typen oder Dateien anhand von Mustern durch und erspart Ihnen so rohe Terminal-Ausgaben.
### Beispiele für präzise Suchanfragen
```bash
# Знайти всі файли, які імпортують утиліту авторизації
Which files import from @/lib/auth or use the useSession hook?
# Знайти всі залишені технічні борги та мітки
Show me all TODO, FIXME, and HACK comments across the codebase with file paths
# Знайти всі виклики конкретної функції
Where is the calculateDiscount function called, and what parameters are passed to it?
# Знайти файли міграцій бази даних
List all migration files in the prisma/migrations/ directory created in the last month
```
Claude verarbeitet die Ergebnisse, gruppiert sie nach Kategorien und erklärt den Kontext jedes gefundenen Vorkommens, anstatt nur eine unzusammenhängende Liste von Zeilen auszugeben.
---
## 5. Analyse und Dekonstruktion komplexer Codeabschnitte
Wenn Sie auf verworrenen Legacy-Code, unverständliche reguläre Ausdrücke oder komplexe Datenverarbeitungspipelines stoßen, wenden Sie sich an Claude für eine detaillierte Analyse.
### Anfragen zur Code-Dekonstruktion
```text
# Розбір ланцюжка проміжних обробників (Middleware)
Explain the middleware execution pipeline in src/server/middleware.ts. What does each middleware do, and in what exact order are they executed?
# Пояснення заплутаного регулярного виразу
This regex in src/utils/validators.ts is hard to read. Break it down part by part and provide examples of matching and non-matching strings.
# Аналіз життєвого циклу компонента
The state management in UserDashboard.tsx looks overly complex. Explain the state flow, what triggers each useEffect, and where race conditions might occur.
```
Der Agent paraphrasiert den Code nicht einfach, sondern analysiert Edge Cases, potenzielle Memory Leaks und Synchronisationsprobleme.
---
## 6. Durchführung von Code Reviews und Git Diff-Analyse
Claude Code eignet sich hervorragend für lokale Audits von Änderungen vor dem Commit oder dem Eröffnen eines Pull Requests.
### Review-Workflow
```bash
# 1. Швидкий аудит застейджених змін перед комітом
git diff --staged | claude -p "Review this diff for bugs, edge cases, security issues, and style problems. Be concise."
# 2. Перевірка розбіжностей між гілкою задачі та main
git diff main...feature-branch | claude -p "Perform a code review of this branch. Focus on performance regressions and breaking changes."
```
### Interaktives Review innerhalb der Session
Wenn Sie sich bereits im interaktiven Modus von Claude befinden, geben Sie einfach ein:
```text
Review the changes I made in the last commit. Look for logic bugs, missing error handling, and potential production bottlenecks.
```
Claude analysiert die Ausgabe von `git diff`, weist auf potenzielle Zuverlässigkeitsprobleme hin und schlägt konkrete Korrekturen vor, bevor Ihre Kollegen den Code sehen.
---
## 7. Modifikations-Tools: Edit, Write und Bash
Das Verständnis, wie Claude Code das Dateisystem modifiziert, ist der Schlüssel zur Kontrolle über die Sicherheit der Codebasis. Für Änderungen nutzt der Agent die Trias der Tools: `Edit`, `Write` und `Bash`.
```mermaid
flowchart LR
subgraph Модифікація_диска["Інструменти редагування"]
E["Edit Tool
(Точкова заміна рядків)"]
W["Write Tool
(Створення / перезапис файлів)"]
B["Bash Tool
(Команди, пакети, збірка)"]
end
E --> D["Диференційний перегляд (Diff)"]
W --> D
B --> D
D --> U{"Підтвердження користувача"}
U -->|Y| S["Збереження на диску"]
U -->|N| R["Скасування правки"]
```
### Das Tool Edit: Präzise chirurgische Änderungen
`Edit` führt eine punktuelle Ersetzung von Textfragmenten durch. Es findet einen eindeutigen Block von Zeilen in einer Datei und ersetzt ihn durch eine aktualisierte Version, wobei der Rest der Datei unberührt bleibt.
```diff
// Приклад візуалізації дифу в терміналі Claude Code:
async function fetchUser(id: string) {
- const response = await fetch(`/api/users/${id}`);
- return response.json();
+ try {
+ const response = await fetch(`/api/users/${id}`);
+ if (!response.ok) {
+ throw new Error(`Failed to fetch user: ${response.status}`);
+ }
+ return await response.json();
+ } catch (error) {
+ console.error('Error fetching user:', error);
+ throw error;
+ }
}
```
Sie sehen immer einen farbigen Diff im Terminal, bevor Sie die Anwendung der Änderung bestätigen.
### Das Tool Write: Erstellung neuer Module
`Write` wird verwendet, um neue Dateien von Grund auf zu generieren oder Konfigurationsdateien vollständig zu aktualisieren:
```text
Create a new utility module at src/lib/formatters.ts with helpers for currency formatting, relative timestamps, and phone numbers. Include JSDoc comments.
```
### Das Tool Bash: Systemoperationen und Verifikation
`Bash` ermöglicht dem Agenten die Interaktion mit dem Betriebssystem: Installation von Paketen, Ausführung von Migrationen, Build des Projekts und Starten von Tests.
```text
Install zod and create a registration form schema in src/schemas/auth.ts, then run typecheck to make sure types align.
```
---
## 8. End-to-End-Änderungen über mehrere Dateien hinweg
Der Hauptvorteil eines vollwertigen agentic Ansatzes gegenüber normalen Chats ist die Fähigkeit, konsistente End-to-End-Refactorings durchzuführen, die verschiedene Architekturschichten betreffen.
```text
Add a 'phoneNumber' field to the User entity. Update the Prisma schema, generate the migration, update the registration API route, and add the input field to the Profile form component.
```
### Wie Claude die Konsistenz der Änderungen sicherstellt
1. **Aktualisierung des Datenschemas:** Bearbeitet `schema.prisma` über `Edit`.
2. **Ausführung der Migration:** Ruft `npx prisma migrate dev` über `Bash` auf.
3. **Aktualisierung der Backend-Validierung:** Fügt Feldvalidierung in die Zod-Schema des Routers `src/app/api/user/route.ts` ein.
4. **Aktualisierung der UI-Oberfläche:** Fügt ein Eingabefeld in die Datei `src/components/ProfileForm.tsx` ein.
5. **Kompilierungsvalidierung:** Startet `npm run typecheck`, um die Abwesenheit von Typkonflikten zu bestätigen.
Jede Aktion erfordert Ihre Bestätigung und gewährleistet so volle Transparenz des Prozesses.
---
## 9. Iterative Verfeinerung und sicheres Rückgängigmachen von Änderungen
Die Entwicklung mit Claude Code ist ein interaktiver Dialog. Wenn eine generierte Änderung Anpassungen erfordert, müssen Sie den gesamten Kontext nicht wiederholen.
### Präzisierung von Änderungen im Kontext der aktuellen Session
```text
# Зміна стилю коду
That looks good, but please replace the if/else statements with a concise switch statement.
# Додавання документації
Great, now add comprehensive JSDoc comments to all exported functions in this file.
# Оптимізація продуктивності
Can we memoize this calculation with useMemo to avoid re-computations on each render?
```
### Mechanismen zum Rückgängigmachen unerwünschter Änderungen
Wenn eine Änderung genehmigt wurde, das Ergebnis aber nicht Ihren Erwartungen entspricht, gibt es zwei zuverlässige Wege, alles rückgängig zu machen:
1. **Über Claude:**
```text
Undo the last changes you made to src/lib/validation.ts and return the file to its previous state.
```
2. **Direkt über Git im Terminal:**
```bash
# Скасувати зміни в конкретному файлі
git checkout -- src/lib/validation.ts
# Скасувати всі незафіксовані зміни в проєкті
git reset --hard HEAD
```
> [!TIP]
> Machen Sie einen sauberen Commit, bevor Sie mit einem umfangreichen Refactoring mit Claude Code beginnen. Dies ermöglicht es Ihnen, jederzeit mit einem einzigen Befehl `git checkout` zum funktionierenden Zustand zurückzukehren.
---
## 10. Ingenieurtechnische Best Practices und abschließende Checkliste
Die Einhaltung bewährter ingenieurtechnischer Praktiken verwandelt Claude Code in einen extrem zuverlässigen Pair-Programming-Partner.
### Vier Regeln für produktive Interaktion
1. **Eine Aufgabe – eine Anfrage:** Mischen Sie keine verschiedenen Features in einem Prompt (*„Füge Authentifizierung hinzu, schreibe die Header-Stile neu und lösche alte Tests“*). Zerlegen Sie die Arbeit in atomare Schritte.
2. **Verifikation durch Compiler und Tests:** Bitten Sie den Assistenten nach Abschluss jeder Serie von Änderungen, das Ergebnis zu überprüfen: `Run npm test and npm run typecheck to make sure everything compiles cleanly`.
3. **Verständnis der Tool-Mechanik:** Denken Sie daran, dass punktuelle Änderungen über `Edit`, neue Dateien über `Write` und Prüfungen über `Bash` laufen. Dies hilft Ihnen, präzisere Anweisungen zu geben.
4. **Kontexthygiene:** Wenn eine Aufgabe erledigt ist und Sie zu einem grundsätzlich anderen Thema wechseln, nutzen Sie den Befehl `/compact` oder starten Sie die Session neu, um den Speicher von unnötigen Logs zu bereinigen.
### Schneller Selbsttest
> **1. Welches Tool verwendet Claude Code für die punktuelle Ersetzung von Codefragmenten ohne vollständiges Überschreiben der Datei?**
>
> > [!TIP]
> > **Antwort:** Das Tool `Edit`. Es findet ein eindeutiges Codefragment und führt die Ersetzung durch, wobei es eine differenzielle Ansicht (Diff) anzeigt.
> **2. Warum lädt Claude Code beim Start nicht alle Projektdateien sofort in den Speicher?**
>
> > [!TIP]
> > **Antwort:** Um die Limits des Kontextfensters nicht zu überschreiten und keine unnötigen Tokens zu verbrauchen. Stattdessen nutzt es gezielte Navigation über `Glob`, `Grep` und `Read`.
> **3. Wie können Sie schnell die Unterschiede des aktuellen PR-Zweigs zu main mit Claude Code prüfen?**
>
> > [!TIP]
> > **Antwort:** Führen Sie im Terminal den Befehl `git diff main...feature-branch | claude -p "Code review this PR"` aus.
### Abschließende Checkliste für die praktische Arbeit
- [ ] Verwenden Sie Überblicks-Prompts für das schnelle Kennenlernen neuer Codebasen.
- [ ] Untersuchen Sie die Architektur über Flow-Nachverfolgungs-Anfragen (*„Trace the flow from UI to database“*).
- [ ] Führen Sie lokale Code Reviews vor dem Erstellen jedes Pull Requests über `claude -p` durch.
- [ ] Überprüfen Sie den farbigen Diff im Terminal sorgfältig, bevor Sie den Aufruf von `Edit` bestätigen.
- [ ] Fixieren Sie den stabilen Zustand über `git commit`, bevor Sie komplexe End-to-End-Änderungen beginnen.
- [ ] Beenden Sie jede Aufgabe immer mit dem Start von Tests und der Prüfung der Typen über `Bash`.