Keybindings Claude Code

Tes doigts s'attendent à ce que Ctrl+K ouvre une palette de commandes. Claude Code a d'autres idées. Chaque mauvais réflexe coûte une seconde de réflexion et un instant de flow.

Le coût s'accumule. Une longue session Claude Code tourne sur la mémoire musculaire, et de mauvais raccourcis par défaut combattent cette mémoire musculaire à chaque frappe. Des années d'habitudes VS Code, Vim, ou Emacs ne se désapprennent pas sur commande. Réentraîner tes mains pour correspondre au layout de raccourcis de quelqu'un d'autre est du temps perdu.

La correction est intégrée. Un seul fichier JSON, organisé par contexte, gère chaque raccourci qui t'importe. Tu obtiens des séquences en accords, des piles de modificateurs, et la possibilité de supprimer un défaut complètement. Les modifications prennent effet dès que tu sauvegardes. Voici comment tout configurer pour que l'outil te ressemble.

Premiers pas avec les keybindings personnalisés

Tape /keybindings dans Claude Code. Cette commande slash crée ou ouvre ~/.claude/keybindings.json pour toi. Le fichier vit dans le dossier habituel ~/.claude/ à côté du reste de tes paramètres.

La forme du fichier est simple :

{
  "$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
      }
    }
  ]
}

Trois clés de premier niveau font tout le travail :

• $schema - Optionnel. Pointer vers l'URL du JSON Schema donne à ton éditeur l'autocomplétion et la validation gratuites. Ça vaut la peine de le garder.
• $docs - Optionnel. Un lien vers la doc pour des recherches rapides.
• bindings - Le tableau où vivent tes raccourcis. Une entrée par contexte.

Ce champ schema est un avantage discret. Tout éditeur avec support JSON Schema suggère alors des actions et des noms de contexte valides pendant que tu tapes.

Les fichiers sauvegardés sont pris en compte à la volée. Modifie, sauvegarde, et les nouveaux bindings fonctionnent immédiatement. Pas de redémarrage.

Comment fonctionnent les contextes

Chaque binding est dans un contexte, et le contexte décide quand le raccourci est actif. Un binding Chat ne se déclenche que quand la zone de saisie principale du chat a le focus. Réutilise les mêmes touches dans différents contextes et elles peuvent chacune faire quelque chose de différent.

Il y a 17 contextes dans Claude Code :

Global est le cas particulier. Un raccourci ici se déclenche peu importe la vue dans laquelle tu es. Utilise-le avec précaution. Un Ctrl+K global se déclenchera dans le chat, dans l'autocomplétion et dans une revue de diff.

Chaque action, listée

Les noms d'action suivent un pattern namespace:action. Voici chaque action dans chaque contexte, avec sa touche par défaut.

Actions globales

Celles-ci se déclenchent partout :

Les gros utilisateurs de la liste de tâches appuient sur app:toggleTodos toute la journée. Si Ctrl+T entre en conflit avec ton terminal, déplace-le quelque part de plus pratique.

Actions Chat

Là où la plupart de tes frappes atterrissent :

Sur Windows sans mode VT, chat:cycleMode retombe sur Meta+M. Ça s'applique aux builds Node antérieurs à 24.2.0/22.17.0, et Bun antérieur à 1.2.23. Le raccourci contrôle les modes de permission, qui régulent ce que Claude a le droit de faire.

Actions History

Revenir sur les prompts passés :

Actions Autocomplete

Actives quand le menu de suggestions est ouvert :

Actions Confirmation

Bindings pour les dialogues de permission et d'approbation :

Actions Transcript

Actions History Search

Actions Task

Actions Theme, Help et Settings

Actions de navigation

Onglets, pièces jointes, pied de page, diffs, sélecteur de modèle, sélections et le sélecteur de messages sont tous là :

Syntaxe des touches

La syntaxe pour définir des combinaisons de touches est facile à lire.

Modificateurs

Joins les touches modificatrices à la touche cible avec + :

• ctrl ou control pour la touche Control
• alt, opt, ou option pour Alt/Option
• shift pour Shift
• meta, cmd, ou command pour Meta/Command

Quelques exemples :

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

Lettres majuscules et Shift

Une lettre majuscule seule signifie déjà Shift. Donc K dans un binding revient au même que shift+k. Pratique pour les layouts de style Vim où j et J (ou k et K) correspondent à des actions différentes.

Un piège. Une fois qu'un modificateur est attaché, la casse ne compte plus. ctrl+K et ctrl+k sont le même binding. Avec des modificateurs, la majuscule est purement cosmétique.

Séquences en accords

Les accords te donnent des raccourcis multi-touches. Mets un espace entre les frappes :

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

Ça ouvre beaucoup plus de possibilités que les bindings à une seule touche. Tu manques de combos de touches inutilisées ? Les accords ajoutent des centaines de nouvelles options sans rien écraser.

Touches spéciales

Les touches non-caractères ont leurs propres noms :

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

Désactiver les raccourcis par défaut

Mets l'action à null et le défaut disparaît :

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

Pratique quand un défaut entre en conflit avec ton terminal, ton OS, ou un autre outil qui tourne à côté de Claude Code. Tu peux aussi mettre un défaut à null et donner ensuite à cette même touche une nouvelle action.

Raccourcis réservés

Deux touches sont codées en dur. Elles ne peuvent pas être reconfigurées :

Claude Code rejettera toute tentative de remapper ces touches, et c'est la bonne décision. Chaque utilisateur de terminal s'attend à ce que Ctrl+C interrompe et Ctrl+D quitte. Ce sont des conventions Unix.

Conflits avec les multiplexeurs de terminal

Tu fais tourner Claude Code dans tmux, GNU screen ou un multiplexeur similaire ? Les touches préfixes vont te poser des problèmes :

task:background est livré avec Ctrl+B, qui est exactement le préfixe tmux. Si tu vis dans tmux, remplace-le dès le premier jour :

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

Ce conflit piège beaucoup de développeurs qui font tourner Claude Code dans des sessions multiplexées.

Interaction avec le mode Vim

Active le mode vim avec /vim et il fonctionne sur une couche séparée des keybindings :

• Mode Vim gère l'édition de texte. Mouvement du curseur, modes INSERT et NORMAL, mouvements, objets de texte.
• Keybindings gèrent les actions au niveau de l'application. Basculer la liste de tâches, envoyer un message, ouvrir le sélecteur de modèle.

La touche Escape est la séparation la plus claire. Dans le mode vim, Escape quitte INSERT et passe en NORMAL. Elle n'appelle pas chat:cancel. La plupart des raccourcis Ctrl+touche passent directement à travers le mode vim vers la couche de keybindings, donc Ctrl+T bascule toujours la liste de tâches même depuis le mode NORMAL.

En mode NORMAL, ? affiche l'aide de style vim, pas l'écran d'aide de Claude Code.

Les gros utilisateurs du mode thinking sur le mode vim devraient placer chat:thinkingToggle derrière un accord qui reste libre des mouvements vim. Le guide du mode interactif couvre comment le mode vim, les commandes slash et le reste des fonctionnalités interactives s'assemblent.

Validation et diagnostics

Claude Code vérifie ton fichier de keybindings à chaque sauvegarde et signale :

• Erreurs de parsing dans la syntaxe ou la structure JSON
• Noms de contexte invalides qui ne correspondent pas aux 17 contextes supportés
• Conflits avec les raccourcis réservés si tu essaies de remapper Ctrl+C ou Ctrl+D
• Conflits avec les multiplexeurs de terminal pour Ctrl+B, Ctrl+A et Ctrl+Z
• Bindings en double dans le même contexte

Lance /doctor pour voir chaque avertissement de keybinding en un seul endroit. C'est le chemin le plus rapide pour comprendre pourquoi un raccourci se comporte mal.

Exemples de configuration pratiques

Quelques configurations tirées de setups réels.

Configuration utilisateur VS Code

Tu viens de VS Code et tu veux retrouver les raccourcis habituels :

{
  "$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"
      }
    }
  ]
}

Setup adapté à tmux

Contourne le clash avec le préfixe tmux :

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

Setup minimal sans distractions

Supprime les raccourcis que tes doigts déclenchent par accident :

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

Power user avec accords

Place les fonctionnalités rares derrière des accords pour garder les combos à une touche libres :

{
  "$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"
      }
    }
  ]
}

Tes actions les plus utilisées gardent leurs bindings à une touche. Tout le reste est à un accord de distance.

Construire ta propre configuration

Vas-y doucement. Reconfigurer toute l'appli en une seule fois est un piège. Voici une approche plus saine :

1. Lance /keybindings pour générer le fichier de config
2. Identifie tes trois pires points de douleur (conflits de raccourcis, bindings manquants, déclenchements accidentels)
3. Corrige ces trois-là d'abord avec des entrées ciblées
4. Lance /doctor pour valider le fichier
5. Passe une session Claude Code complète dessus et note ce qui accroche encore
6. Itère en ajoutant ou modifiant les bindings au fur et à mesure que les frictions apparaissent

Personnaliser chaque raccourci possible n'est pas l'objectif. L'objectif est de réduire l'écart entre ce que tes mains attendent et ce que Claude Code fait. Cinq à dix bindings suffisent généralement pour que l'outil te semble naturel.

Les keybindings gèrent le côté physique. CLAUDE.md et les commandes slash personnalisées gèrent le côté comportemental. Combine les deux et Claude Code commence à ressembler à un outil construit autour de ton workflow.