Commandes slash de Claude Code : des sessions plus longues et plus propres

Commandes slash vs indicateurs CLI vs raccourcis clavier

Les indicateurs CLI configurent le lancement de Claude Code, les raccourcis clavier gèrent les interruptions en temps réel, et les commandes slash vous offrent un contrôle fin une fois dans la session. 

Ces trois couches existent car les besoins varient selon les moments du flux de travail. Vous ne les utiliserez pas toutes à chaque session, mais savoir qu'elles existent vous permet de saisir le bon outil au bon moment.

Les commandes slash se tapent directement dans une session active. Elles commencent par / (p. ex., /compact, /plan ou /clear) et s'exécutent immédiatement. Elles contrôlent ce qui se passe maintenant, dans la conversation en cours.

Les indicateurs CLI se définissent au lancement de Claude Code depuis le terminal. Des commandes comme claude --model claude-opus-4-6 ou claude --continue sont des indicateurs CLI. Ils configurent la session avant qu'elle ne démarre. Vous pouvez en savoir plus sur toute la palette d'options dans notre tutoriel Claude Code CLI.

Les raccourcis clavier opèrent au niveau de l'interface. Esc interrompt une réponse en cours. Un double appui sur Esc ouvre le menu d'annulation. Shift+Tab bascule entre le mode plan, l'acceptation des modifications et le mode auto. Ces gestes doivent devenir réflexes pour vos actions fréquentes.

Cet article se concentre sur les commandes slash, à utiliser entre deux invites, avec des rappels de raccourcis clavier quand ils recouvrent une commande spécifique.

Quelles commandes Claude Code sont les plus importantes ?

Le tableau suivant couvre les 13 commandes clé, toutes détaillées dans ce guide.

Notez que /cost est désormais un alias de /usage dans les versions récentes de Claude Code, et que /fork est un alias de /branch.

Vous pouvez explorer toutes les options en tapant / dans votre session Claude.

Comment gérer la fenêtre de contexte de Claude Code

Pour gérer la fenêtre de contexte dans Claude Code, une compétence essentielle pour tout utilisateur avancé, utilisez les commandes /compact, /clear et /context.

Qu'est-ce que la fenêtre de contexte dans Claude Code ?

La fenêtre de contexte est la mémoire de travail de votre session. Elle contient beaucoup d'informations : 

• L'historique de conversation
• Le contenu des fichiers
• Les sorties de commandes
• Vos instructions CLAUDE.md
• Le contexte MCP
• Les invites système de Claude

Au fil du remplissage, Claude Code perd de vue des éléments précédents de la session : la structure de fichiers décrite au départ, les contraintes énoncées, et d'autres informations clés. La qualité baisse avant même d'atteindre la limite, pas seulement à l'impact.

/compact

La commande /compact résume les anciens tours de conversation et les remplace par une version compressée, libérant ainsi des jetons tout en gardant Claude conscient de ce qui s'est passé plus tôt dans la session. Bonne pratique : l'exécuter tôt et être explicite sur ce qu'il faut préserver.

L'appel de base est simplement /compact. Plus utile encore : indiquer ce qu'il faut conserver. Par exemple : /compact focus on the auth module, ou /compact retain the error handling patterns we discussed.

Lorsque vous fournissez des instructions, le résumé généré par Claude mettra l'accent sur ces sujets. Pour les data practitioners : /compact focus on the schema decisions and the pipeline DAG, afin que l'architecture globale reste en vue pendant que les détails ligne à ligne sont compressés.

Règle utile de la communauté : compacter avant que l'utilisation du contexte ne dépasse 80 %. Attendre qu'il soit saturé réduira la qualité du résumé, car Claude fonctionne déjà en mode dégradé.

Point important : le contenu de CLAUDE.md, les skills chargées et les fichiers de mémoire sont automatiquement préservés lors de la compaction. Inutile de les demander explicitement.

/clear

La commande /clear efface entièrement l'historique de conversation et redémarre à neuf. Utilisez /clear aux frontières de tâches.

Vous pouvez facultativement passer un nom pour étiqueter la session avant l'effacement : /clear payment-refactor. Cela nomme l'ancienne session dans le sélecteur /resume pour y revenir plus tard.

Quand vous terminez le débogage d'un chargeur de données et que vous attaquez un module de visualisation sans rapport, traîner l'ancien contexte devient un frein. Un nouveau départ évite les confusions de références, les contraintes dépassées, et remet toute l'attention sur la nouvelle tâche.

Utilisez /compact pour poursuivre le même travail avec un contexte allégé, et /clear pour basculer vers un travail différent.

/context

Avant de décider de compacter ou d'effacer, mieux vaut savoir où vous en êtes vraiment. La commande /context visualise l'utilisation actuelle de la fenêtre de contexte sous forme de grille colorée et montre précisément où partent les jetons.

Vous verrez une ventilation par catégorie : 

• Historique de conversation
• Contenu des fichiers
• Fichiers mémoire
• Skills chargées

L'intérêt : Claude proposera des pistes d'optimisation si un élément consomme anormalement de place. Passez all pour élargir à la décomposition détaillée : /context all

Prenez l'habitude d'exécuter /context avant toute grosse tâche. Si la fenêtre est déjà à 60 % à cause d'échanges précédents, lancer un gros refactoring multi-fichiers sans compacter ou effacer au préalable vous expose à des frictions.

Comment planifier et relire les changements dans Claude Code

La façon la plus rapide de créer du chaos avec du code « au feeling », c'est de laisser l'IA éditer des fichiers sans plan clair. Pour éviter que des instructions ambiguës ne produisent des modifications incohérentes, utilisez /plan et diff.

/plan

La commande /plan place Claude en mode lecture seule : il analyse la base de code, propose un plan d'action et attend votre validation avant toute modification. 

Vous pouvez l'accompagner d'une description pour le lancer sur de bons rails : /plan refactor the feature engineering pipeline to support lazy evaluation. Il n'écrira ni ne supprimera rien sans votre feu vert. Après relecture et approbation, Claude exécute le plan complet.

Le raccourci clavier pour basculer en mode plan est Shift+Tab, plus rapide que la saisie si vous êtes en cours de session.

Le mode plan est surtout utile dans 3 situations : 

• Quand vous ne connaissez pas bien une base de code
• Quand un changement touche de nombreux fichiers
• Quand les instructions sont intrinsèquement ambiguës

Cela vaut pour des tâches comme migrer un feature store, refactorer une logique ETL ou mettre à jour des scripts d'entraînement de modèles qui ont accumulé des modifications ponctuelles.

Pour aller plus loin, lisez notre tutoriel dédié : Claude Code Plan Mode : boucles de refactoring orientées revue de conception.

/diff

La commande /diff ouvre un visualiseur diff interactif affichant tous les changements de fichiers de la session en cours.

Idéal pour vérifier rapidement qu'aucune surprise ne s'est glissée : changements de fichiers inattendus, élargissement de périmètre non désiré, etc. Pensez-y comme au dernier point de contrôle entre « Claude a fait des choses » et « je sais exactement ce qui entre dans ce commit ».

Dans le visualiseur, naviguez avec les flèches. Gauche/droite basculent entre le diff git cumulé courant et les diffs par tour. Haut/bas parcourent les fichiers de la vue. Vous voyez ainsi ce qui s'est passé sur l'ensemble de la session et à chaque tour.

Comment garder Claude Code sur les rails

Pour éviter que des sessions complexes ne perdent le fil et ne saturent le contexte de digressions, utilisez /goal et /btw.

/goal

La commande /goal de Claude Code fixe un objectif de haut niveau qui persiste au fil des tours et maintient Claude orienté vers un résultat défini. 

Une fois l'objectif posé, Claude avance automatiquement jusqu'à ce que la condition indiquée soit remplie. Particulièrement utile pour des migrations longues, des corrections massives de tests, ou toute tâche qui obligerait sinon à relancer Claude à chaque étape.

Utilisez-la en énonçant le résultat visé. Des objectifs clairs et bien bornés aident, par exemple : /goal All tests in the data pipeline are passing with no deprecation warnings.

Un bandeau de progression en direct s'affiche dans la barre d'état avec le temps écoulé, le nombre de tours et l'usage de jetons pendant l'objectif. Quand il est atteint, Claude s'arrête et signale la fin. 

Pour retirer un objectif avant son aboutissement : /goal clear.

Pour une approche proche mais différente, lisez notre tutoriel sur le développement guidé par spécifications dans Claude Code.

/btw

La commande /btw permet de poser une question annexe qui ne rejoint jamais le fil principal de la conversation.

Claude y répond dans un volet superposé, et la conversation principale reprend exactement où elle en était : /btw what was that config option for SQLAlchemy connection pooling called again? 

Je rencontre souvent ce cas : Claude travaille et une question de procédure me vient. Si j'interromps Claude pour demander, j'ajoute du bruit et il devra peut-être relancer la tâche. Si j'ignore la question, je la perds. /btw résout cela proprement.

Voyez-la comme un pense-bête glissé en plein travail : la réponse utile, sans le coût de contexte ni la digression.

Comment naviguer entre les sessions dans Claude Code

Les projets longs ne tiennent pas en une seule session. Il faut reprendre d'anciens travaux, expérimenter sans casser les acquis, et parfois annuler des changements qui ont dérapé. Les commandes /resume, /branch et /rewind servent à tout cela.

/resume

La commande /resume permet de continuer une session précédente. Sans argument, vous obtenez un sélecteur listant les sessions récentes par date avec un rappel du dernier prompt. Passez un nom ou un ID de session pour y accéder directement : /resume payment-refactor

Vous pouvez aussi le faire en ligne de commande avant d'ouvrir une session. claude --continue (ou claude -c) reprend la plus récente, et claude --resume <id> reprend via l'ID. Les indicateurs CLI et la commande slash accomplissent la même chose : les CLI avant de démarrer, la commande slash au milieu d'une session.

Claude Code enregistre chaque session en local dans ~/.claude/projects/ au format JSONL, avec chaque message, outil et résultat. C'est ce qui rend possible la reprise, le retour arrière et le branchement.

/branch

La commande /branch crée une copie de la conversation dans son état actuel, vous bascule dessus et laisse l'originale intacte. Vous pouvez nommer vos branches : /branch try-polars-instead-of-pandas

C'est l'équivalent conversationnel d'une branche git. Vous voulez tester une autre voie sans perdre celle déjà construite ? Branchez, testez, et si cela ne fonctionne pas, /resume sur l'originale. Si ça marche, vous conservez une branche propre reflétant la meilleure piste.

Cette approche est aussi utile quand la fenêtre de contexte se remplit et que deux sujets distincts dépendent tous deux du contexte collecté dans l'échange actif.

/branch existe aussi sous /fork, et dans d'anciennes ressources vous verrez souvent /fork. Le nom canonique dans la documentation actuelle est /branch, mais les deux fonctionnent.

/rewind

Si vous allez trop loin et réalisez qu'une erreur s'est glissée… /rewind ramène la session à un tour précédent, comme un bouton d'annulation pratique. 

Le point fort : un menu interactif. Naviguez aux flèches et sélectionnez le tour de retour.

La clé : choisir quoi rembobiner :

• Les deux (par défaut) : les fichiers sont restaurés à l'état de ce tour, et les messages ultérieurs sont supprimés. À utiliser quand une série de changements a dérapé et qu'il faut repartir proprement d'un état sain.
• Conversation uniquement : supprime les messages après le point choisi, conserve les changements de code. Utile si les réponses de Claude étaient peu utiles, mais que le code généré est bon.
• Code uniquement : restaure les fichiers à l'état sélectionné mais garde la conversation. Utile si vous voulez conserver l'analyse tout en annulant les modifications de fichiers.

Le raccourci Esc Esc ouvre le même menu sans taper la commande.

Important : seuls les opérations de fichiers effectuées par les outils officiels de Claude sont tracées et réversibles. Les changements réalisés manuellement dans un éditeur externe ne le sont pas.

Comment contrôler les coûts et les performances dans Claude Code

Pour optimiser le ratio coût/performances dans Claude Code, utilisez /cost, /model et /effort.

Avec une offre API, la dépense en jetons compte. Avec les offres Pro ou Max, respecter le quota est clé. Dans tous les cas, faire tourner le modèle le plus puissant au raisonnement maximal sur chaque tâche est du gaspillage.

/cost

/cost est un alias de /usage et affiche ce que vous avez consommé jusqu'ici :

• Pour les utilisateurs API, il affiche le nombre de jetons, l'usage du cache et le coût en dollars par modèle. 
• Pour les abonnés Pro et Max, il montre votre consommation par rapport au quota de la période de facturation.

Utile : vérifier /cost au début d'une session lourde pour fixer un point de référence, puis périodiquement pendant les longues exécutions pour suivre la combustion du budget. 

Si les coûts grimpent plus vite que prévu, les deux commandes suivantes sont vos leviers.

/model

Changer de modèle actif avec /model en cours de session, sans perdre le contexte, est très utile quand vos besoins évoluent.

Sans argument, la commande ouvre un sélecteur interactif navigable aux flèches. Vous pouvez aussi passer le nom directement : /model claude-haiku-4-5.

Stratégie pratique : 

1. Démarrer avec Claude Opus pour le raisonnement architectural complexe
2. Puis basculer sur Claude Sonnet pour l'implémentation
3. Descendre sur Claude Haiku pour le travail mécanique : renommage de variables, docstrings, gabarits. 

L'écart de coût entre Opus et Haiku est d'environ 10 à 20 fois à l'échelle.

Depuis la v2.1.153, le modèle sélectionné via /model est enregistré comme défaut pour les nouvelles sessions. Appuyez sur s dans le sélecteur pour n'appliquer le choix qu'à la session en cours sans changer votre défaut.

/effort

Vous pouvez ajuster l'/effort de votre modèle et fixer la profondeur de raisonnement pour la session. Sans argument, vous obtenez un curseur interactif, mais vous pouvez aussi définir directement : /effort low.

Niveaux disponibles : 

• low

• medium

• high

• xhigh (avril 2026)

• max (mai 2026)

• ultracode (mai 2026)

Les niveaux max et ultracode sont limités à la session et ne peuvent pas être enregistrés par défaut. Utilisez /effort auto pour revenir au défaut du modèle actif.

Le niveau ultracode combine le raisonnement xhigh avec une orchestration automatique de workflows pour les tâches multi-étapes les plus complexes. Attention, cela peut consommer beaucoup de jetons, l'orchestration pouvant lancer plus de 100 agents.

Règle pratique : 

• Privilégiez low ou medium pour le générique, la génération simple de code et les refactorings évidents. 

• Réservez high ou xhigh au débogage complexe, aux choix d'architecture et aux analyses multi-fichiers où bien faire du premier coup évite des allers-retours.

• Utilisez ultracode uniquement pour les grands refactorings, les réécritures de bases de code ou les tâches à nombreuses dépendances. 

L'effort influe directement sur la qualité et le coût en jetons : le calibrer à la tâche est payant.

Comment créer des commandes slash personnalisées dans Claude Code

Les commandes intégrées couvrent l'opérationnel de base. Les commandes slash personnalisées donnent l'impression d'un outil façonné pour vous.

L'idée est simple : toute invite que vous retapez régulièrement peut être enregistrée comme fichier de commande et invoquée par un simple /nom-de-commande. La check-list standard de revue de code de votre équipe, les étapes de vérification de déploiement de votre projet, ou votre manière de demander des tests deviennent partageables. 

Commandes slash vs skills d'agent

Point d'attention : Anthropic a unifié commandes personnalisées et skills. Le format .claude/commands/ est désormais considéré comme légacy. Il reste fonctionnel et le CLI le supporte, mais le format recommandé est .claude/skills/<name>/SKILL.md. 

Les skills s'invoquent pareil via /name, peuvent aussi être déclenchées automatiquement par Claude selon la description, et peuvent embarquer des fichiers de support (scripts, modèles, docs référence) aux côtés de l'invite. 

Pour en savoir plus, consultez notre tutoriel sur Claude Skills.

Où vivent les commandes personnalisées

Les commandes personnalisées sont des fichiers Markdown stockés à deux emplacements :

• Niveau projet : .claude/commands/ à la racine du projet. Portée projet, commitables, et partagées avec toute personne sur le même dépôt.

• Personnel (global) : ~/.claude/commands/ dans votre répertoire personnel. Disponibles sur tous vos projets et privées.

Le nom de fichier sans l'extension .md devient le nom de commande. Un fichier .claude/commands/fix-issue.md crée /fix-issue. Un fichier .claude/commands/frontend/component.md crée /component avec un label d'espace de noms indiquant sa provenance du sous-dossier frontend.

En format skills, les chemins équivalents sont .claude/skills/<command-name>/SKILL.md pour le projet et ~/.claude/skills/<command-name>/SKILL.md pour le personnel. Le frontmatter et le corps de l'invite fonctionnent identiquement.

Le format de fichier

Le corps du fichier Markdown est le modèle d'invite. À l'appel, Claude lit le fichier, applique les substitutions et l'exécute comme si vous aviez saisi cette invite.

Voici un exemple minimal pour .claude/commands/summarize-pr.md :

Review the current git diff and write a concise pull request description.
Include: what changed, why it changed, and any important implementation notes.
Format as plain prose, not bullet points.

Lancez /summarize-pr, et Claude exécute cette invite sur la session en cours.

Ajouter un frontmatter YAML

Pour mieux contrôler le comportement d'une commande, ajoutez un frontmatter YAML en tête de fichier :

description: Generate a PR description from the current diff
allowed-tools: Bash(git diff *), Read
model: claude-sonnet-4-6

Le frontmatter est utile pour plusieurs raisons :

• description apparaît dans la liste /help pour vous rappeler le rôle de la commande, et pour que Claude puisse la faire correspondre automatiquement quand vous décrivez un besoin sans l'appeler explicitement.

• Comme son nom l'indique, allowed-tools restreint les outils utilisables par Claude à l'exécution, pratique pour borner la portée et le contexte. 

• Enfin, model fige la commande sur un modèle spécifique quel que soit le modèle actif en session.

Utiliser $ARGUMENTS

Le placeholder $ARGUMENTS rend les commandes personnalisées très souples. Tout texte saisi après le nom de la commande est substitué partout où $ARGUMENTS figure dans l'invite.

Exemple complet : créons une commande de correction d'anomalies intitulée .claude/commands/fix-issue.md :

---
description: Find and fix a GitHub issue by number
allowed-tools: Read, Edit, Bash(git diff *)
argument-hint: [issue-number]
---

Find and fix issue #$ARGUMENTS in this repository.

Steps:
1. Read the relevant source files to understand the current behavior
2. Identify the root cause
3. Implement the fix with minimal scope — do not change unrelated code
4. Verify the fix does not break anything obvious
5. Write a brief explanation of what changed and why

Vous l'appelez via /fix-issue 847, et Claude reçoit l'invite avec $ARGUMENTS remplacé par 847. Vous pouvez également utiliser les arguments positionnels $0, $1, etc., pour des commandes à multiples entrées distinctes.

Injecter la sortie du shell en direct

Les commandes peuvent injecter une sortie shell en direct avec le préfixe !. Idéal pour des commandes qui doivent toujours s'appuyer sur l'état courant :

allowed-tools: Read, Bash(git *)
description: Review staged changes before committing

Current staged diff:
!git diff --cached

Review these changes and suggest a clear, conventional commit message.
Flag any obvious bugs, missing tests, or incomplete logic before I commit.

Au chargement, Claude exécute git diff --cached, capture la sortie et l'injecte dans l'invite. Claude voit le diff réel, pas un placeholder.

Cette combinaison de $ARGUMENTS, d'injection shell et de frontmatter rend les commandes personnalisées de Claude Code efficaces pour accélérer vos invites. 

Pour plus de motifs et d'exemples concrets, les tutoriels de DataCamp sur Claude Code : bonnes pratiques et Claude Code Hooks montrent comment ces outils s'articulent dans des workflows de production.

Pour conclure

Les commandes slash ne sont pas des fonctions avancées réservées aux power users. Elles constituent la couche opérationnelle de base de Claude Code, et les apprendre tôt change votre manière d'aborder le développement assisté par l'IA.

Si vous débutez, allez-y pas à pas. Adoptez /compact, /plan et /cost comme leviers simples mais puissants pour optimiser vos sessions. Une fois ces réflexes acquis, ajoutez /diff avant les commits et /goal pour toute tâche qui s'étale sur plusieurs tours. Le reste viendra avec les besoins.

Pour plus d'idées de commandes personnalisées, poursuivez avec notre tutoriel Claude Code Terminal. Pour poser des bases structurées sur la façon de raisonner des modèles Claude et leurs cas d'usage, nos cours Introduction to Claude Models et Claude Code 101 sont idéaux.