# Workflow-Tipps

Dieser Leitfaden zeigt, wie Sie Claude Code in Ihren täglichen Entwicklungsworkflow integrieren – von der persönlichen Effizienz bis zur Teamzusammenarbeit – und wie Sie effiziente KI-gestützte Entwicklungsprozesse etablieren.

## Plan-Ausführung-Workflow

Das effektivste Claude Code-Muster ist **erst planen, dann ausführen** – vermeiden Sie, dass die KI direkt Code schreibt.

### Grundablauf

```
1. Analyze Requirements → 2. Create Plan → 3. Confirm Plan → 4. Execute Step by Step → 5. Verify Results
```

### Praktische Schritte

**Schritt 1: Claude die Anforderungen verstehen lassen**

```
> Read the code in @src/services/ directory and understand the existing architecture.
> Don't write any code, just analyze.
```

**Schritt 2: Implementierungsplan erstellen**

```
> Based on your understanding of the existing code, create a detailed implementation plan for "user permission management".
> Include: file changes, new files, dependencies, risk points.
```

**Schritt 3: Plan bestätigen und anpassen**

Prüfen Sie Claudes Plan und schlagen Sie Änderungen vor:

```
> In step 3 of the plan, I want to use Redis cache instead of memory cache. Please adjust the plan.
```

**Schritt 4: Schrittweise ausführen**

```
> Now execute step 1 of the plan: create the permission model.
```

Nach Abschluss jedes Schritts Ergebnisse verifizieren, bevor Sie fortfahren.

## Feature-Branch-Workflow

### Best Practices für Git-Branches

```bash
# 1. Create feature branch
git checkout -b feature/user-permissions

# 2. Navigate to project and start Claude Code
cd your-project && claude

# 3. Commit frequently during development
> /commit  # First commit
# Continue developing...
> /commit  # Second commit

# 4. Feature complete, create PR
> Create a PR description for the current branch, summarizing all commit changes
```

### Tipps zur Commit-Häufigkeit

- **Kleine Commits**: Nach jedem unabhängigen Funktionspunkt committen

- **Commit-Messages**: `/commit` verwenden, um automatisch korrekte Messages zu generieren

- **Große Commits vermeiden**: Nicht zu viele Änderungen ansammeln, bevor committet wird

## Code-Review-Workflow

### Selbstüberprüfung

Vor dem Einreichen eines PRs von Claude prüfen lassen:

```
> /review
> Focus on: security, performance, code style
```

### Code anderer prüfen

```bash
# Get PR changes
gh pr diff 123 | claude "Review this PR, focus on:
1. Logic correctness
2. Edge case handling
3. Error handling
4. Code maintainability"
```

### Mehrstufiger Review-Prozess

Für komplexe PRs strukturiertes Review verwenden:

```
> Phase 1: Check if architecture design is reasonable
> Phase 2: Check if implementation matches design
> Phase 3: Check if test coverage is sufficient
> Phase 4: Check if documentation is complete
```

## Testgetriebener Workflow

### TDD mit Claude Code

```
1. Write Tests → 2. Run Tests (Fail) → 3. Write Code → 4. Run Tests (Pass) → 5. Refactor
```

### Praktische Schritte

**Schritt 1: Tests definieren**

```
> Write test cases for user registration, covering:
> - Normal registration
> - Invalid email format
> - Weak password
> - User already exists
> Write tests first, don't implement the feature.
```

**Schritt 2: Prüfen, dass Tests fehlschlagen**

```bash
npm test  # Expected: tests fail
```

**Schritt 3: Funktion implementieren**

```
> Now implement the code to make all tests pass.
```

**Schritt 4: Verifizieren und refactoring**

```bash
npm test  # Expected: tests pass
```

```
> Tests pass. Now refactor the code for better readability without breaking tests.
```

## Debugging-Workflow

### Strukturiertes Debugging

```
1. Reproduce Issue → 2. Gather Information → 3. Analyze Cause → 4. Verify Hypothesis → 5. Fix Issue
```

### Praktische Schritte

**Schritt 1: Problem beschreiben**

```
> Issue: After login, clicking "My Orders" shows blank page
> Expected: Display user's order list
> Steps to reproduce: Login → Click "My Orders"
```

**Schritt 2: Informationen sammeln**

```
> Analyze these files to find possible issues:
> @src/pages/MyOrders.tsx
> @src/services/OrderService.ts
> @src/api/orders.ts
```

**Schritt 3: Logs analysieren**

```bash
# Collect error logs
cat app.log | claude "Analyze these logs, find errors related to the orders page"
```

**Schritt 4: Beheben und verifizieren**

```
> Based on the analysis, fix the issue in OrderService
> After fixing, I'll test to verify
```
## Workflow für die Zusammenarbeit mit Subagents

### Parallele Verarbeitung

Nutzen Sie Subagents, um Aufgaben parallel zu bearbeiten:

```
> Execute these tasks simultaneously:
> 1. Use Explore agent to analyze project structure
> 2. Use Plan agent to design new feature approach
```

### Spezialisierte Rollen

Verschiedene Subagents haben unterschiedliche Stärken:

| Agent | Spezialgebiet | Anwendungsfall |
|-------|---------------|----------------|
| Explore | Schnelle Suche | Code finden, Struktur verstehen |
| Plan | Architekturentwurf | Planung komplexer Features |
| Background | Parallele Verarbeitung | Stapelaufgaben, lang laufende Aufgaben |

## Workflow für die IDE-Integration

### VS Code-Integration

1. Installieren Sie die Claude Code VS Code-Erweiterung

2. Wechseln Sie mit `Cmd+Esc` / `Ctrl+Esc` schnell zwischen den Fenstern

3. Markieren Sie Code im Editor und rufen Sie dann Claude auf

### Zusammenarbeit von Terminal und IDE

```
Terminal (Claude Code)          IDE (VS Code)
        ↓                           ↓
   Analyze, Plan              Manual adjustments, reading
        ↓                           ↓
   Generate Code  ←─────────→   View diff, test
        ↓                           ↓
   Commit Code                  Continue development
```

## Workflow für die Teamarbeit

### Standardisierte CLAUDE.md

Teilen Sie die CLAUDE.md-Konfiguration im gesamten Team:

```markdown
# Team Development Standards

## Code Style
- ESLint config: .eslintrc.js
- Prettier config: .prettierrc

## Git Standards
- Branch naming: feature/xxx, fix/xxx, hotfix/xxx
- Commit format: type(scope): description

## Testing Requirements
- Unit test coverage > 80%
- E2E tests cover core flows
```

### PR-Vorlagen

Lassen Sie Claude einheitliche PR-Vorlagen verwenden:

```
> Create PR description using this template:
> ## Changes
> ## Test Plan
> ## Screenshots (if UI changes)
> ## Checklist
```

## Workflow-Checkliste

### Vor dem Start einer neuen Aufgabe

- [ ] Feature-Branch erstellen

- [ ] Kontext mit `/clear` leeren

- [ ] Claude zuerst den bestehenden Code verstehen lassen

- [ ] Umsetzungsplan erstellen

### Während der Entwicklung

- [ ] Schritt für Schritt vorgehen und jeden Schritt überprüfen

- [ ] Kleine Commits, häufig `/commit` verwenden

- [ ] Kontext mit `/context` im Blick behalten

- [ ] Bei Bedarf `/compact` verwenden

### Vor dem Einreichen

- [ ] Mit `/review` eine Selbstprüfung durchführen

- [ ] Alle Tests ausführen

- [ ] Auf Lint-Fehler prüfen

- [ ] PR-Beschreibung generieren

## Nächste Schritte

- Lernen Sie die [CLI-Tipps](/docs/usage/cli-tips) für weitere Befehle kennen

- Entdecken Sie [Benutzerdefinierte Befehle](/docs/usage/cli-tips), um teamspezifische Befehle zu erstellen

- Lesen Sie die [Best Practices](/docs/usage/best-practices), um Ihre Workflows weiter zu optimieren