# CLI-Tipps

Dieser Leitfaden umfasst 34 praktische Claude Code Tipps – von grundlegenden Operationen bis hin zu erweiterten Funktionen – damit Sie das volle Potenzial von Claude Code ausschöpfen.

## Grundlegende Operationen

### 1. Tab-Autocomplete für Dateipfade

Drücken Sie nach der Eingabe von `@` die Taste `Tab`, um Dateipfade automatisch zu vervollständigen – Sie müssen sich keine vollständigen Pfade merken.

### 2. Dateien präzise mit @ referenzieren

```
> Analyze security in @src/utils/auth.ts
> Compare @v1/api.js with @v2/api.js
```

Direkte Dateireferenzen sind genauer als eine Beschreibung der Dateispeicherorte.

### 3. Eingaben per Pipe zur Analyse übergeben

```bash
git diff | claude "explain these changes"
cat error.log | claude "analyze error causes"
npm test 2>&1 | claude "analyze test failures"
```

### 4. Tastenkombinationen

| Tastenkombination | Funktion |
|----------|----------|
| `Tab` | Dateipfade automatisch vervollständigen |
| `Esc` | Aktuelle Ausgabe unterbrechen |
| `Ctrl+C` | Aktuelle Operation abbrechen |
| `↑` / `↓` | Befehlsverlauf durchblättern |
| `Shift+Tab` (zweimal) | In den Plan-Modus wechseln |
| `Alt+Tab` / `Option+Tab` | Thinking-Modus umschalten |

### 5. Schnellbefehle mit !

Stellen Sie `!` voran, um Shell-Befehle direkt auszuführen:

```
> !git status
> !npm run build
```

## Schrägstrichbefehle

### 6. /help – Alle Befehle anzeigen

```
> /help
```

Zeigt alle verfügbaren Schrägstrichbefehle und Tastenkombinationen an.

### 7. /clear – Unterhaltung löschen

```
> /clear
```

Löschen Sie den Kontext vor neuen Aufgaben, um Störungen durch vorherige Unterhaltungen zu vermeiden.

### 8. /compact – Verlauf komprimieren

```
> /compact
```

Verwenden Sie dies bei zu langem Kontext – komprimiert den Verlauf, um Tokens zu sparen und gleichzeitig die Kerninformationen beizubehalten.

### 9. /context – Kontextnutzung prüfen

```
> /context
```

Zeigt den aktuellen Kontext-Nutzungsprozentsatz an. Erwägen Sie bei 60 % eine Komprimierung oder eine neue Sitzung.

### 10. /model – Modelle wechseln

```
> /model opus
> /model sonnet
```

- **Opus 4.7 / 4.6**: Komplexe Aufgaben, Architekturdesign, schwierige Probleme (4.7 ist das aktuelle Flaggschiff)

- **Sonnet 4.6**: Tägliche Codierung, schnelle Iterationen (kostengünstig)

### 11. /memory – Projektgedächtnis bearbeiten

```
> /memory
```

Öffnet die CLAUDE.md-Datei zur Bearbeitung von Projektstandards und -präferenzen.

### 12. /init – Projektkonfiguration initialisieren

```
> /init
```

Lassen Sie Claude Ihr Projekt analysieren und eine CLAUDE.md-Konfigurationsdatei generieren.

### 13. /commit – Intelligenter Commit

```
> /commit
```

Analysiert Änderungen automatisch, erzeugt passende Commit-Nachrichten und führt den Commit durch.

### 14. /review – Code-Review

```
> /review
```

Überprüft aktuelle Änderungen auf potenzielle Probleme.

### 15. /resume – Sitzung fortsetzen

```
> /resume
```

Setzen Sie eine vorherige Unterhaltungssitzung fort, um unvollendete Arbeiten weiterzuführen.

## Kontextverwaltung

Claude Code hat eine Kontextgrenze von ~200K Tokens. Konzentrieren Sie eine Sitzung auf eine Aufgabe, verwenden Sie `/context` zur Überwachung der Nutzung, `/compact` zur Komprimierung des Verlaufs und `/clear` für einen Neuanfang.

Ausführliche Strategien zur Kontextverwaltung (einschließlich Behandlung von Überlauf in langen Sitzungen) → [Kontextverwaltung](/docs/usage/context-management)

## Plan-Modus

### 19. In den Plan-Modus wechseln

Drücken Sie `Shift+Tab` zweimal, um in den Plan-Modus zu wechseln. Claude recherchiert und erstellt Pläne, ohne Code zu modifizieren.

### 20. Erst planen, dann ausführen

Lassen Sie Claude bei komplexen Aufgaben zunächst einen Plan erstellen:

```
> Analyze this feature requirement and create an implementation plan, don't write code yet
```

Bestätigen Sie den Plan vor der Ausführung, um Nacharbeiten zu reduzieren.

### 21. Komplexe Aufgaben schrittweise ausführen

Teilen Sie große Aufgaben in kleinere Schritte auf:

```
> Step 1: Analyze the existing auth system
> Step 2: Design the new JWT approach
> Step 3: Implement core functionality
> Step 4: Add tests
```
## Subagents

### 22. Explore Agent für schnelle Suche nutzen

Der Explore Agent ist auf schnelle Codebase-Suchen spezialisiert:

```
> Use the Explore agent to find all payment handling code
```

### 23. Plan Agent für Design nutzen

Der Plan Agent ist auf Implementierungsplanung spezialisiert:

```
> Use the Plan agent to design the user permission system
```

### 24. Background Agents für parallele Aufgaben

Starten Sie mehrere Background Agents, um Aufgaben parallel zu verarbeiten und so die Effizienz zu steigern.

## CLAUDE.md-Konfiguration

`CLAUDE.md` ist eine projektweite Konfigurationsdatei, die Claude beim Start automatisch einliest. Nutzen Sie `/init`, um eine solche Datei zu generieren, oder erstellen Sie sie manuell. Definieren Sie Code-Standards, häufige Befehle und die Projektarchitektur, um sich in jeder Sitzung nicht wiederholen zu müssen.

Vollständiger Konfigurationsleitfaden mit Beispielen → [CLAUDE.md-Konfiguration](/docs/usage/claude-md)

## Git-Workflow

### 28. Smarte Commit-Nachrichten

```
> /commit
```

Claude analysiert alle Änderungen und generiert passende Commit-Nachrichten.

### 29. PR-Beschreibungen erstellen

```
> Create a PR description for the current branch
```

Erzeugt automatisch PR-Beschreibungen mit Änderungszusammenfassung und Testplan.

### 30. PR-Änderungen analysieren

```bash
gh pr diff 123 | claude "review this PR"
```

## Testing & Debugging

### 31. Claude Tests schreiben lassen

```
> Write unit tests for @src/services/UserService.ts
```

Lassen Sie Claude Tests schreiben, um die Korrektheit des eigenen Codes zu überprüfen.

### 32. Testfehler analysieren

```bash
npm test 2>&1 | claude "analyze failures and fix"
```

### 33. Fehler debuggen

```
> Analyze this error: [paste error message]
> Debug the issue in @src/pages/Login.tsx
```

## Fortgeschrittene Tipps

### 34. Screenshots/Bilder nutzen

Claude Code unterstützt Bildverständnis:

```
> Look at this screenshot @screenshot.png and analyze UI issues
```

## Effizienzvergleich

| Szenario | Traditionell | Claude Code |
|----------|-------------|-------------|
| Code finden | grep + manuelles Durchsuchen | `@file` oder Explore agent |
| Tests schreiben | Manuell + Debugging | `/review` + Auto-Generierung |
| Git-Commit | Nachricht überlegen + schreiben | `/commit` auf Knopfdruck |
| Code-Review | Zeile für Zeile prüfen | `/review` smarte Analyse |
| Code verstehen | Doku lesen + Code lesen | Einfach Claude fragen |

## Best-Practice-Zusammenfassung

1. **Präzise formulieren**: Anforderungen mit Rahmenbedingungen klar beschreiben

2. **Referenzen nutzen**: `@` verwenden, um Dateien anzugeben, statt raten zu müssen

3. **Schrittweise vorgehen**: Komplexe Aufgaben in kleinere Schritte zerlegen

4. **Früh unterbrechen**: `Esc` drücken, sobald eine Ausgabe fehlerhaft ist

5. **Fokussiert bleiben**: Eine Sitzung für eine Aufgabe

6. **Regelmäßig komprimieren**: `/compact` nutzen, wenn der Kontext zu lang wird

7. **Erst planen**: Vor komplexen Aufgaben einen Plan erstellen

8. **KI testen lassen**: Claude Tests schreiben lassen, um den Code zu verifizieren

## Nächste Schritte

- Erfahren Sie mehr über [Workflow-Tipps](/docs/usage/workflow-tips) für effiziente Entwicklungsprozesse

- Entdecken Sie [Kontextverwaltung](/docs/usage/context-management) für die Behandlung langer Sitzungen und Token-Überschreitung

- Richten Sie die [CLAUDE.md-Konfiguration](/docs/usage/claude-md) ein, um Claudes Verhalten für Ihr Projekt anzupassen

- Sehen Sie sich die [Codex-Integration](/docs/ide/codex) an, um ein weiteres KI-Tool zu nutzen