# Claude Code Befehle: Cheat Sheet mit Flags und Shortcuts

URL: https://agentvera.dev/de/blog/claude-code-commands-cheat-sheet/ · Veröffentlicht: 2026-10-23

Alle wichtigen Claude Code Befehle auf einer Seite: CLI-Flags, Slash-Befehle, Tastenkürzel, @-Erwähnungen, !-Shell-Modus, Memory-Dateien und eigene Skills.

**Kurz gesagt:**

- /clear startet eine neue Unterhaltung mit leerem Kontext, /compact ersetzt den Verlauf durch eine Zusammenfassung und nimmt Anweisungen entgegen, was erhalten bleiben soll.
- Eigene Slash-Befehle sind jetzt Skills: ein Ordner mit einer SKILL.md in .claude/skills/ oder ~/.claude/skills/, und der Ordnername wird zum Befehl.
- Sessions werden pro Ordner gespeichert, daher findet claude -c deine letzte Unterhaltung nur, wenn du es im selben Projektverzeichnis ausführst.

Die Claude Code Befehle, die du am häufigsten brauchst, sind `claude` zum Starten einer Session, `claude -p "..."` für eine einmalige Antwort, `claude -c` zum Fortsetzen, `/clear` und `/compact` für die Kontextverwaltung, `/model` zum Modellwechsel, `Shift+Tab` zum Wechsel des Permission-Modus und `Esc`, um Claude mitten im Turn zu stoppen. Dazu kommen `@` für eine Datei-Erwähnung, `!` für einen Shell-Befehl, und deine eigenen Skills werden zu `/name`-Befehlen. Die Tabellen unten gruppieren alles nach Aufgabe, und jeder Eintrag wurde anhand der offiziellen Claude-Code-Doku geprüft.

Lass diese Seite in einem zweiten Tab offen. Wenn du das Tool neu kennenlernst, beginne mit [Claude Code nutzen: der Einstieg](/de/blog/how-to-use-claude-code/ "Claude Code nutzen") und komm hierher zurück, wenn du die Kürzel suchst.

## Sessions starten und fortsetzen

Diese laufen in deiner Shell, bevor Claude Code startet.

| Befehl | Was er tut |
| --- | --- |
| `claude` | Startet eine interaktive Session im aktuellen Ordner |
| `claude "explain this repo"` | Startet eine Session mit einem ersten Prompt |
| `claude -p "query"` | Print-Modus: einmal antworten und beenden, gut für Skripte |
| `cat log.txt \| claude -p "why does this fail?"` | Leitet Inhalt in eine einmalige Anfrage |
| `claude -c` | Setzt die letzte Unterhaltung in diesem Ordner fort |
| `claude -c -p "query"` | Setzt sie nicht interaktiv fort |
| `claude -r "<session>" "query"` | Setzt eine Session per ID oder Name fort |
| `claude update` | Aktualisiert auf die neueste Version |
| `claude doctor` | Prüft Installation und Einstellungen auf Probleme |
| `claude mcp` | Konfiguriert MCP-Server |
| `claude auth login` / `claude auth logout` | An- oder abmelden (`claude auth status` zeigt das aktuelle Konto) |

Sessions werden pro Ordner gespeichert. `claude -c` in einem anderen Verzeichnis findet die Unterhaltung aus deinem Projekt nicht.

## CLI-Flags, die du dir merken solltest

Die [CLI-Referenz](https://code.claude.com/docs/en/cli-reference "Claude Code CLI reference") listet Dutzende Flags und weist darauf hin, dass `claude --help` nicht alle zeigt. Diese greifen die meisten Leute zuerst.

### Session und Ausgabe

| Flag | Was es tut |
| --- | --- |
| `--print`, `-p` | Nicht interaktiver Modus |
| `--continue`, `-c` | Lädt die letzte Unterhaltung in diesem Ordner |
| `--resume`, `-r` | Setzt eine bestimmte Session fort oder lässt dich eine wählen |
| `--fork-session` | Startet beim Fortsetzen eine neue Session-ID, statt die alte weiterzuverwenden |
| `--name`, `-n` | Gibt der Session einen Anzeigenamen |
| `--output-format` | `text`, `json` oder `stream-json` im Print-Modus |
| `--max-turns` | Begrenzt die Zahl der Agent-Turns im Print-Modus |
| `--max-budget-usd` | Stoppt einen Print-Modus-Lauf nach einem Dollarbetrag |
| `--verbose` | Zeigt die vollständige Ausgabe Turn für Turn |
| `--version`, `-v` | Gibt die Version aus |

### Modell und Effort

| Flag | Was es tut |
| --- | --- |
| `--model sonnet` | Wählt ein Modell per Alias (`sonnet`, `opus`, `haiku`) oder vollem Namen |
| `--fallback-model` | Modell, auf das ausgewichen wird, wenn das Hauptmodell überlastet ist (Print-Modus) |
| `--effort` | Setzt die Effort-Stufe, etwa `low`, `medium`, `high` oder `max` |

### Berechtigungen und Tools

| Flag | Was es tut |
| --- | --- |
| `--permission-mode plan` | Startet in einem Modus: `default`, `acceptEdits`, `plan`, `auto`, `dontAsk`, `bypassPermissions` |
| `--allowedTools "Bash(npm test)"` | Lässt diese Tools ohne Rückfrage laufen |
| `--disallowedTools "Bash(git push *)"` | Nimmt diese Tools aus der Reichweite des Modells |
| `--dangerously-skip-permissions` | Dasselbe wie `bypassPermissions`. Nur in isolierten Umgebungen |
| `--add-dir ../shared` | Gibt Claude Zugriff auf einen weiteren Ordner |

Das letzte ist ein grobes Werkzeug. Unser Beitrag zum [sicheren Überspringen von Berechtigungen](/de/blog/claude-code-skip-permissions/ "Claude Code Berechtigungen überspringen, aber sicher") behandelt die sichereren Alternativen.

### Konfiguration und Kontext

| Flag | Was es tut |
| --- | --- |
| `--append-system-prompt "..."` | Hängt Text an den Standard-System-Prompt an |
| `--system-prompt "..."` | Ersetzt den System-Prompt vollständig |
| `--mcp-config ./mcp.json` | Lädt MCP-Server aus einer Datei |
| `--settings ./settings.json` | Lädt zusätzliche Einstellungen aus einer Datei oder einem JSON-String |
| `--agents '{...}'` | Definiert Subagenten inline als JSON |
| `--worktree`, `-w` | Startet in einem isolierten Git-Worktree |
| `--ide` | Verbindet sich beim Start mit deiner IDE, wenn genau eine verfügbar ist |
| `--debug` | Schaltet die Debug-Ausgabe ein |

## Eingebaute Slash-Befehle

Tippe `/` am Anfang einer Nachricht, um das Menü zu öffnen. Ein Befehl wird nur ganz am Anfang der Nachricht erkannt. Manche Einträge sind Skills, die mit Claude Code ausgeliefert werden, du rufst sie aber genauso auf. Die vollständige Liste steht in der [Befehlsreferenz](https://code.claude.com/docs/en/commands "Claude Code commands").

### Kontext und Unterhaltung

| Befehl | Was er tut |
| --- | --- |
| `/clear` | Startet eine neue Unterhaltung mit leerem Kontext |
| `/compact [instructions]` | Fasst die Unterhaltung zusammen, um Kontext freizugeben |
| `/context` | Zeigt, was das Kontextfenster füllt |
| `/resume` | Wählt eine frühere Session zum Fortsetzen |
| `/rename` | Benennt die aktuelle Session um |
| `/branch [name]` | Verzweigt die Unterhaltung ab hier |
| `/rewind` | Geht zu einem früheren Punkt in Code, Unterhaltung oder beidem zurück (auch `/checkpoint`, `/undo`) |
| `/btw [question]` | Stellt eine Zwischenfrage, ohne sie dem Haupt-Thread hinzuzufügen |
| `/export [filename]` | Exportiert die Unterhaltung als Klartext |
| `/copy` | Kopiert Claudes letzte Antwort |

### Modell, Kosten und Limits

| Befehl | Was er tut |
| --- | --- |
| `/model [model]` | Wechselt das Modell |
| `/effort` | Ändert die Effort-Stufe |
| `/fast` | Schaltet den Fast-Modus um |
| `/usage` | Zeigt Nutzung und Plan-Limits (`/cost` und `/stats` sind Aliase) |
| `/status` | Version, Modell, Konto und Verbindungsstatus |

Wenn deine Limits zu schnell aufgebraucht sind, lies [warum Claude Code so viele Tokens verbraucht](/de/blog/claude-code-token-usage/ "Claude Code Token-Verbrauch").

### Projekt-Setup

| Befehl | Was er tut |
| --- | --- |
| `/init` | Erzeugt eine `CLAUDE.md` als Startpunkt für das Projekt |
| `/memory` | Öffnet und bearbeitet deine Memory-Dateien |
| `/add-dir <path>` | Fügt ein Arbeitsverzeichnis hinzu |
| `/config` | Öffnet die Einstellungen (Theme, Editor-Modus und mehr) |
| `/permissions` | Zeigt und bearbeitet Allow-, Ask- und Deny-Regeln |
| `/hooks` | Verwaltet Hooks |
| `/mcp` | Verwaltet MCP-Server und ihre Anmeldungen |
| `/plugin` | Durchsucht und installiert Plugins |
| `/skills` | Listet verfügbare Skills |
| `/statusline` | Richtet die Statuszeile ein |
| `/terminal-setup` | Installiert die Shift+Enter-Tastenbelegung in Terminals, die sie brauchen |
| `/keybindings` | Öffnet deine Datei mit den Tastenbelegungen |

### Code-Review und Planung

| Befehl | Was er tut |
| --- | --- |
| `/plan [description]` | Wechselt in den Plan-Modus, optional mit einer Aufgabe |
| `/diff` | Prüft die Änderungen in deinem Working Tree, einschließlich Claudes Edits |
| `/code-review` | Prüft die aktuellen Änderungen (`/review` ist ein Alias) |
| `/security-review` | Prüft die Änderungen deines Branches auf Sicherheitsprobleme |
| `/simplify` | Räumt kürzlich geänderten Code auf |

### Hilfe und Verwaltung

| Befehl | Was er tut |
| --- | --- |
| `/help` | Zeigt die Hilfe |
| `/doctor` | Diagnostiziert die Installation |
| `/ide` | Verwaltet IDE-Integrationen und zeigt den Status |
| `/tasks` | Listet Hintergrundaufgaben |
| `/login` / `/logout` | Wechselt oder meldet Konten ab |
| `/release-notes` | Zeigt, was sich geändert hat |
| `/feedback` | Sendet Feedback (auch `/bug`) |
| `/exit` | Beendet (auch `/quit`) |

`/vim` wurde entfernt. Die Vim-Tasten findest du jetzt unter `/config` → Editor mode.

## Tastenkürzel

Aus der [Doku zum interaktiven Modus](https://code.claude.com/docs/en/interactive-mode "Claude Code interactive mode"). Unter macOS muss dein Terminal für die `Option`-Kürzel Option als Meta senden.

### Die Session steuern

| Kürzel | Was es tut |
| --- | --- |
| `Esc` | Stoppt Claude mitten im Turn |
| `Esc` `Esc` | Leert den Entwurf oder öffnet Rewind, wenn die Eingabe leer ist |
| `Ctrl+C` | Unterbricht oder leert die Eingabe |
| `Ctrl+D` | Beendet die Session (zweimal drücken) |
| `Shift+Tab` | Wechselt durch die Permission-Modi (normal, Edits automatisch akzeptieren, Plan usw.) |
| `Option+P` / `Alt+P` | Wechselt das Modell |
| `Option+T` / `Alt+T` | Schaltet Extended Thinking um |
| `Ctrl+O` | Öffnet den Transcript-Viewer |
| `Ctrl+B` | Schiebt einen laufenden Befehl oder Agenten in den Hintergrund |
| `Ctrl+T` | Zeigt die Aufgaben-Checkliste |
| `Ctrl+L` | Zeichnet den Bildschirm neu |

### Prompts schreiben

| Kürzel | Was es tut |
| --- | --- |
| `Ctrl+R` | Durchsucht den Prompt-Verlauf |
| `Ctrl+G` | Öffnet den Prompt im externen Editor |
| `Ctrl+V` | Fügt ein Bild ein (`Alt+V` unter Windows) |
| `Ctrl+S` | Legt den Prompt beiseite; in einem leeren Prompt erneut drücken, um ihn wiederherzustellen |
| `\` dann `Enter` | Neue Zeile (funktioniert überall) |
| `Shift+Enter` | Neue Zeile in iTerm2, WezTerm, Ghostty, Kitty, Warp, Apple Terminal und Windows Terminal |
| `Ctrl+J` | Neue Zeile |
| `Ctrl+A` / `Ctrl+E` | Springt zum Anfang / Ende der Zeile |
| `Ctrl+U` / `Ctrl+K` | Löscht bis zum Anfang / Ende der Zeile |
| `Ctrl+W` | Löscht das vorherige Wort |

Wenn `Shift+Enter` deinen Prompt absendet, statt eine Zeile einzufügen, führe `/terminal-setup` aus.

## Eingabepräfixe: @, ! und ?

| Präfix | Wo | Was es tut |
| --- | --- | --- |
| `/` | Nachrichtenanfang | Führt einen Befehl oder Skill aus |
| `!` | Nachrichtenanfang | Shell-Modus: führt den Befehl direkt aus |
| `@` | Überall | Erwähnt einen Datei- oder Ordnerpfad, mit Autovervollständigung |
| `?` | Leere Eingabe | Zeigt die Hilfe zu den Kürzeln |

Ein paar Details, die Zeit sparen:

- `@src/auth.ts` legt die Datei in die Unterhaltung. `@src/` listet den Ordner auf.
- `! npm test` führt den Befehl aus, fügt Befehl und Ausgabe dem Kontext hinzu, und Claude reagiert darauf. Der Shell-Modus läuft außerhalb der Sandbox, und `Tab` vervollständigt aus deinen früheren `!`-Befehlen.
- Wenn du dich an ein `#`-Kürzel zum Hinzufügen von Memories erinnerst: Es steht nicht in der aktuellen Doku. Nutze `/memory` oder sag Claude einfach, es soll sich etwas merken.

## Memory-Dateien

| Datei | Geltungsbereich |
| --- | --- |
| `~/.claude/CLAUDE.md` | Du, in jedem Projekt |
| `./CLAUDE.md` | Das Projekt, per Git geteilt |
| `./CLAUDE.local.md` | Du, nur in diesem Projekt (nicht in Git einchecken) |

In einer Memory-Datei importiert `@path/to/file` eine andere Datei. Imports lassen sich bis zu vier Ebenen tief verschachteln. Die [Memory-Doku](https://code.claude.com/docs/en/memory "Claude Code memory") empfiehlt, jede Datei unter etwa 200 Zeilen zu halten. Neuere Versionen lesen auch `AGENTS.md`. Was in diese Dateien gehört, steht in [CLAUDE.md und AGENTS.md](/de/blog/claude-md-agents-md/ "CLAUDE.md und AGENTS.md").

## Eigene Slash-Befehle mit Skills

Eigene Befehle sind jetzt Skills. Jeder Skill ist ein Ordner mit einer `SKILL.md`, und der Ordnername wird zum Befehl. Mehr dazu in der [Skills-Doku](https://code.claude.com/docs/en/skills "Claude Code skills").

| Ort | Befehl | Wer ihn bekommt |
| --- | --- | --- |
| `~/.claude/skills/review-pr/SKILL.md` | `/review-pr` | Du, überall |
| `.claude/skills/deploy/SKILL.md` | `/deploy` | Alle im Repo |
| `.claude/commands/deploy.md` | `/deploy` | Älteres Format, funktioniert weiter |
| Der Skill eines Plugins | `/plugin-name:skill-name` | Wer das Plugin installiert hat |

Ein minimaler Skill, der ein Argument entgegennimmt:

```markdown
---
name: fix-issue
description: Fix a GitHub issue
disable-model-invocation: true
---

Fix GitHub issue $ARGUMENTS following our coding standards.
Read the issue, write a failing test, fix it, run the tests.
```

Jetzt übergibt `/fix-issue 482` die `482` als `$ARGUMENTS`. Für Positionsargumente nutzt du `$0`, `$1` (oder `$ARGUMENTS[0]`). `disable-model-invocation: true` bedeutet, dass nur du ihn aufrufen kannst. Ohne die Option kann Claude den Skill auch von sich aus verwenden, wenn die Beschreibung passt. Weitere nützliche Frontmatter-Felder sind `argument-hint`, `allowed-tools` und `model`.

## Fünf Gewohnheiten für den guten Umgang mit diesen Befehlen

1. **Bei allem Nicht-Trivialen zuerst planen.** Mit `Shift+Tab` in den Plan-Modus oder `/plan add rate limiting`. Lies den Plan, bevor sich eine Datei ändert.
2. **Zwischen Aufgaben leeren.** `/clear`, wenn du das Thema wechselst. Alter Kontext kostet Tokens und verwirrt das Modell.
3. **Mit Anweisungen komprimieren.** `/compact keep the schema decisions and the failing test names` behält, was zählt.
4. **Wiederholte Prompts in Skills verwandeln.** Wenn du denselben Absatz zweimal pro Woche einfügst, sollte daraus `/something` werden.
5. **Zurückspulen statt diskutieren.** `Esc` `Esc` oder `/rewind` ist schneller, als Claude zu bitten, den eigenen Fehler rückgängig zu machen.

## Wenn ein Terminal nicht reicht

Diese Befehle wirken jeweils auf eine Session. Sobald drei oder vier Claude-Code-Agenten an verschiedenen Aufgaben laufen, ist das Schwierige, den Überblick zu behalten, welcher gerade auf dich wartet. [AgentVera](/de/agents/claude-code/ "Claude Code in AgentVera") ist eine Desktop-App, die jeden Agenten in einem eigenen Pane in einem Raster pro Projekt ausführt. Claude Code läuft dabei weiter als echte CLI, sodass jedes Flag, jeder Slash-Befehl und jeder Skill dieser Seite genauso funktioniert.

Einiges, was die App rund um diese Befehle ergänzt:

- **Ein Workspace mit eigenen Kürzeln.** Der [Workspace](/de/features/workspace/ "Workspace") hat eine ⌘K-Befehlspalette, die Aktionen, Agenten und Projekte durchsucht, ⌘1–9 zum Springen zwischen Panes und Kürzel, die du neu belegen kannst.
- **Skills in einer Liste.** Die [Skill-Galerie](/de/features/skill-gallery/ "Skill-Galerie") listet die Claude-Code-Skills in `.claude/skills` und `~/.claude/skills` auf, lässt dich einen abschalten, ohne ihn zu löschen, und installiert Galerie-Skills nach einem Sicherheitsscan.
- **Checkpoints pro Turn.** [Checkpoints](/de/features/checkpoints-and-replay/ "Checkpoints und Replay") sichern den Ordner zu Beginn jedes Turns, zusätzlich zum eigenen `/rewind` von Claude Code.
- **Ausgabe an einen Agenten senden.** [Send to agent](/de/features/send-to-agent/ "Send to agent") reicht eine Terminal-Auswahl, einen Diff oder ein Log an den Agenten weiter, den du mit ⌘⇧L wählst.

Es ersetzt nicht das Lernen der obigen Befehle. Es hilft, wenn viele Sessions zu steuern sind.

Um AgentVera auszuprobieren, beginne auf der [Startseite](/de/ "AgentVera").

## Häufige Fragen

**Wie sehe ich alle Claude Code Befehle?** Tippe in einer interaktiven Session / ein, um das Befehlsmenü mit den eingebauten Befehlen und deinen Skills zu öffnen. /help zeigt die Hilfe, ? im leeren Prompt die Liste der Tastenkürzel, und claude --help in einer Shell die wichtigsten CLI-Flags.

**Was ist der Unterschied zwischen /clear und /compact?** /clear startet eine frische Unterhaltung mit leerem Kontext. /compact behält die Unterhaltung, ersetzt aber den Verlauf durch eine Zusammenfassung, und mit Anweisungen wie /compact keep the API decisions steuerst du, was die Zusammenfassung behält.

**Wie erstelle ich einen eigenen Slash-Befehl in Claude Code?** Erstelle einen Skill: einen Ordner mit einer SKILL.md-Datei in .claude/skills/ für das Projekt oder ~/.claude/skills/ für dich selbst. Der Ordnername wird zum Befehl, aus .claude/skills/deploy/SKILL.md wird also /deploy. Ältere .claude/commands/*.md-Dateien funktionieren weiterhin.

**Fügt das #-Kürzel in Claude Code noch Memories hinzu?** Die aktuelle Doku zum interaktiven Modus nennt als Eingabepräfixe nur /, ! und @ sowie ? für die Hilfe. Zum Bearbeiten des Memorys öffne mit /memory deine CLAUDE.md-Dateien oder bitte Claude, sich etwas zu merken; dann schreibt es das auf.

**Wie setze ich eine frühere Claude Code Session fort?** Mit claude -c setzt du die letzte Unterhaltung im aktuellen Ordner fort, mit claude -r wählst du eine aus einer Liste. In einer Session öffnet /resume dieselbe Auswahl. Sessions gelten pro Ordner, führe den Befehl also im Projekt aus, in dem du gearbeitet hast.

---

**Über AgentVera.** AgentVera ist eine Desktop-App für macOS, Windows und Linux, entwickelt von Solviera Teknoloji. Sie führt 18 KI-Coding-Agenten (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) nebeneinander aus, pro Projekt, in echten Terminals mit den eigenen CLI-Installationen und Logins des Nutzers. Der kostenlose Plan hat unbegrenzt viele Agenten. Download: https://agentvera.dev/de/download/ · Preise: https://agentvera.dev/de/pricing/