Claude Code Keybindings

Deine Finger erwarten Ctrl+K für eine Befehlspalette. Claude Code hat andere Ideen. Jeder falsche Reflex kostet eine Sekunde Nachdenken und unterbricht den Flow.

Der Preis summiert sich. Eine lange Claude Code-Session läuft auf Muskelgedächtnis, und schlechte Standardbelegungen kämpfen bei jedem Tastendruck dagegen an. Jahre mit VS Code, Vim oder Emacs verlernen sich nicht auf Kommando. Deine Hände auf jemand anderes' Shortcut-Layout umzuschulen ist verschwendete Mühe.

Die Lösung ist eingebaut. Eine JSON-Datei, nach Kontext organisiert, verwaltet jeden Shortcut, der dir wichtig ist. Du bekommst Chord-Sequenzen, Modifier-Stacks und die Option, einen Standard komplett abzuschalten. Änderungen greifen sofort beim Speichern. So verdrahtest du das Tool so, dass es sich wie deins anfühlt.

Erste Schritte mit eigenen Keybindings

Tippe /keybindings in Claude Code. Dieser Slash-Befehl erstellt oder öffnet ~/.claude/keybindings.json für dich. Die Datei liegt im üblichen ~/.claude/-Ordner neben deinen restlichen Einstellungen.

Die Dateistruktur ist einfach:

{
  "$schema": "https://platform.claude.com/docs/schemas/claude-code/keybindings.json",
  "$docs": "https://code.claude.com/docs/en/keybindings",
  "bindings": [
    {
      "context": "Chat",
      "bindings": {
        "ctrl+e": "chat:externalEditor",
        "ctrl+u": null
      }
    }
  ]
}

Drei Keys auf oberster Ebene erledigen die ganze Arbeit:

• $schema - Optional. Das Zeigen auf die JSON-Schema-URL gibt deinem Editor kostenlose Autovervollständigung und Validierung. Lohnt sich zu behalten.
• $docs - Optional. Ein Docs-Link für schnelle Nachschlagevorgänge.
• bindings - Das Array, in dem deine Shortcuts leben. Ein Eintrag pro Kontext.

Das Schema-Feld ist ein stiller Gewinn. Jeder Editor mit JSON-Schema-Unterstützung schlägt dann gültige Aktionen und Kontextnamen beim Tippen vor.

Gespeicherte Dateien werden live aufgegriffen. Bearbeite, speichere, und die neuen Bindings funktionieren sofort. Kein Neustart.

Wie Kontexte funktionieren

Jedes Binding liegt innerhalb eines Kontexts, und der Kontext entscheidet, wann der Shortcut aktiv ist. Ein Chat-Binding feuert nur, wenn das Haupt-Chat-Eingabefeld Fokus hat. Nutze dieselben Tasten in mehreren Kontexten und sie können jeweils etwas anderes tun.

Es gibt 17 Kontexte in Claude Code:

Global ist die Ausnahme. Ein Shortcut hier feuert egal welche Ansicht gerade aktiv ist. Damit vorsichtig sein. Ein globales Ctrl+K löst im Chat, in der Autovervollständigung und in einer Diff-Überprüfung aus.

Alle Aktionen, aufgelistet

Aktionsnamen folgen dem Muster namespace:action. Hier ist jede Aktion in jedem Kontext, mit ihrem Standardkey.

Globale Aktionen

Diese feuern überall:

Wer die Aufgabenliste viel nutzt, drückt app:toggleTodos den ganzen Tag. Wenn Ctrl+T mit deinem Terminal kollidiert, verleg es an einen besser geeigneten Platz.

Chat-Aktionen

Wo die meisten deiner Tastatureingaben landen:

Auf Windows ohne VT-Modus fällt chat:cycleMode auf Meta+M zurück. Das gilt für Node-Builds älter als 24.2.0/22.17.0 und Bun älter als 1.2.23. Der Shortcut steuert Berechtigungsmodi, die bestimmen, was Claude tun darf.

Verlauf-Aktionen

Durch vergangene Prompts navigieren:

Autovervollständigungs-Aktionen

Aktiv, solange das Vorschlags-Menü offen ist:

Bestätigungs-Aktionen

Bindings für Berechtigungs- und Genehmigungsdialoge:

Transkript-Aktionen

Verlauf-Such-Aktionen

Aufgaben-Aktionen

Theme-, Hilfe- und Einstellungs-Aktionen

Navigations-Aktionen

Tabs, Anhänge, Footer, Diffs, Modell-Picker, Auswahlen und der Nachrichten-Selektor:

Tastenkombinations-Syntax

Die Syntax für Tastenkombinationen ist leicht lesbar.

Modifier-Tasten

Verbinde Modifier-Tasten mit der Zieltaste durch +:

• ctrl oder control für die Steuerungstaste
• alt, opt oder option für Alt/Option
• shift für Umschalt
• meta, cmd oder command für Meta/Command

Ein paar Beispiele:

ctrl+k          Single modifier + key
shift+tab       Shift + Tab
meta+p          Command/Meta + P
ctrl+shift+c    Multiple modifiers

Großbuchstaben und Shift

Ein einzelner Großbuchstabe bedeutet bereits Shift. Also ist K in einem Binding dasselbe wie shift+k. Praktisch für Vim-artige Layouts, wo j und J (oder k und K) auf verschiedene Aktionen gemappt sind.

Ein Haken. Sobald ein Modifier hinzugefügt wird, spielt die Groß-/Kleinschreibung keine Rolle mehr. ctrl+K und ctrl+k sind dasselbe Binding. Mit Modifiern ist Großschreibung rein kosmetisch.

Chord-Sequenzen

Chords geben dir mehrtastige Shortcuts. Setze ein Leerzeichen zwischen die Tastenanschläge:

ctrl+k ctrl+s Press Ctrl+K, release, then press Ctrl+S

Das öffnet viel mehr Spielraum als eintastige Bindings. Dir gehen ungenutzte Tastenkombinationen aus? Chords fügen hunderte frische Optionen hinzu, ohne etwas zu überschreiben.

Sondertasten

Nicht-Zeichen-Tasten haben ihre eigenen Namen:

• escape oder esc
• enter oder return
• tab
• space
• up, down, left, right
• backspace, delete

Standard-Shortcuts deaktivieren

Setze die Aktion auf null und der Standard verschwindet:

{
  "bindings": [
    {
      "context": "Chat",
      "bindings": {
        "ctrl+s": null
      }
    }
  ]
}

Praktisch, wenn ein Standard mit deinem Terminal, deinem Betriebssystem oder einem anderen Tool kollidiert, das neben Claude Code läuft. Du kannst auch einen Standard auf null setzen und dann derselben Taste eine neue Aktion geben.

Reservierte Shortcuts

Zwei Tasten sind fest codiert. Sie können nicht neu belegt werden:

Claude Code lehnt jeden Versuch ab, diese neu zu mappen, und das ist richtig so. Jeder Terminal-Nutzer erwartet, dass Ctrl+C abbricht und Ctrl+D beendet. Das sind Unix-Konventionen.

Terminal-Multiplexer-Konflikte

Du nutzt Claude Code in tmux, GNU screen oder einem ähnlichen Multiplexer? Die Präfix-Tasten werden dich beißen:

task:background ist mit Ctrl+B belegt, was genau das tmux-Präfix ist. Wenn du in tmux lebst, belege es am ersten Tag um:

{
  "bindings": [
    {
      "context": "Task",
      "bindings": {
        "ctrl+b": null,
        "ctrl+shift+b": "task:background"
      }
    }
  ]
}

Dieser Konflikt stolpert viele Entwickler, die Claude Code in gemultiplexten Sessions betreiben.

Vim-Modus-Interaktion

Schalte den Vim-Modus mit /vim ein und er arbeitet auf einer separaten Ebene von Keybindings:

• Vim-Modus verwaltet Textbearbeitung. Cursor-Bewegung, INSERT- und NORMAL-Modus, Motions, Text-Objekte.
• Keybindings verwalten App-Level-Aktionen. Aufgabenliste umschalten, eine Nachricht absenden, den Modell-Picker öffnen.

Die Escape-Taste zeigt die klarste Trennung. Im Vim-Modus verlässt Escape INSERT und wechselt zu NORMAL. Es ruft nicht chat:cancel auf. Die meisten Ctrl+Taste-Shortcuts schneiden direkt durch den Vim-Modus in die Keybinding-Ebene, also schaltet Ctrl+T die Aufgabenliste noch aus dem NORMAL-Modus um.

Im NORMAL-Modus ruft ? die Vim-Hilfe auf, nicht Claude Codes Hilfe-Bildschirm.

Wer viel im Thinking-Modus mit Vim-Modus arbeitet, sollte chat:thinkingToggle hinter einem Chord parken, der klar von Vim-Motions getrennt bleibt. Der Interactive-Mode-Guide zeigt, wie Vim-Modus, Slash-Befehle und der Rest der interaktiven Features zusammenpassen.

Validierung und Diagnose

Claude Code prüft deine Keybindings-Datei bei jedem Speichern und meldet:

• Parse-Fehler in JSON-Syntax oder -Struktur
• Ungültige Kontextnamen, die nicht zu den 17 unterstützten Kontexten passen
• Reservierte Shortcut-Konflikte, wenn du versuchst, Ctrl+C oder Ctrl+D neu zu belegen
• Terminal-Multiplexer-Konflikte für Ctrl+B, Ctrl+A und Ctrl+Z
• Doppelte Bindings im selben Kontext

Führe /doctor aus, um alle Keybinding-Warnungen auf einen Blick zu sehen. Das ist der schnellste Weg herauszufinden, warum ein Shortcut sich falsch verhält.

Praktische Konfigurationsbeispiele

Ein paar Konfigurationen aus realen Setups.

VS Code-Nutzer-Konfiguration

Du kommst von VS Code und willst die üblichen Shortcuts zurück:

{
  "$schema": "https://platform.claude.com/docs/schemas/claude-code/keybindings.json",
  "bindings": [
    {
      "context": "Chat",
      "bindings": {
        "ctrl+k ctrl+s": "chat:stash",
        "ctrl+shift+p": "chat:modelPicker",
        "ctrl+g": "chat:externalEditor"
      }
    },
    {
      "context": "Global",
      "bindings": {
        "ctrl+shift+t": "app:toggleTodos"
      }
    }
  ]
}

tmux-freundliches Setup

Umgeht den tmux-Präfix-Konflikt:

{
  "$schema": "https://platform.claude.com/docs/schemas/claude-code/keybindings.json",
  "bindings": [
    {
      "context": "Task",
      "bindings": {
        "ctrl+b": null,
        "ctrl+shift+b": "task:background"
      }
    }
  ]
}

Minimales Ablenkungssetup

Deaktiviere die Shortcuts, die deine Finger ständig aus Versehen drücken:

{
  "$schema": "https://platform.claude.com/docs/schemas/claude-code/keybindings.json",
  "bindings": [
    {
      "context": "Chat",
      "bindings": {
        "ctrl+s": null,
        "ctrl+u": null
      }
    }
  ]
}

Chord-basiertes Power-User-Setup

Park seltenere Features hinter Chords, damit eintastige Kombis frei bleiben:

{
  "$schema": "https://platform.claude.com/docs/schemas/claude-code/keybindings.json",
  "bindings": [
    {
      "context": "Chat",
      "bindings": {
        "ctrl+k ctrl+t": "chat:thinkingToggle",
        "ctrl+k ctrl+m": "chat:modelPicker",
        "ctrl+k ctrl+e": "chat:externalEditor"
      }
    }
  ]
}

Deine meistgenutzten Aktionen behalten ihre eintastigen Bindings. Alles andere ist einen Chord entfernt.

Deine eigene Konfiguration bauen

Langsam angehen. Die gesamte App in einem Durchgang neu zu belegen ist eine Falle. So gehst du vernünftiger vor:

1. Führe /keybindings aus, um die Konfigurationsdatei zu erstellen
2. Wähle deine drei schlimmsten Schmerzpunkte (Shortcut-Kollisionen, fehlende Bindings, versehentliche Auslöser)
3. Behebe diese drei zuerst mit gezielten Einträgen
4. Führe /doctor aus, um die Datei zu validieren
5. Verbring eine vollständige Claude Code-Session damit und notiere, was noch hängt
6. Iteriere, indem du Bindings hinzufügst oder anpasst, wo Reibung auftritt

Jeden möglichen Shortcut anzupassen ist nicht das Ziel. Das Ziel ist, die Lücke zwischen dem, was deine Hände erwarten, und dem, was Claude Code tut, zu schließen. Fünf bis zehn Bindings reichen meist aus, damit das Tool sich nativ anfühlt.

Keybindings verwalten die physische Seite. CLAUDE.md und eigene Slash-Befehle verwalten die Verhaltensseite. Verdrahte sie zusammen und Claude Code fängt an, sich so anzufühlen, als wäre es um deinen Workflow herum gebaut.