---
title: Toutes les commandes slash de Claude Code : rôle, usage et niveau
source: https://synapx.fr/blog/claude-code-commandes-slash/
date: 2026-06-26
category: Claude Code
site: SynapxLab
---

# Toutes les commandes slash de Claude Code

Dans Claude Code, taper **`/`** ouvre une palette d'environ 90 commandes. Il n'est ni nécessaire ni souhaitable de toutes les mémoriser : la palette se filtre au fur et à mesure de la saisie et permet de retrouver rapidement l'action adaptée. Ce guide les classe par usage et précise leur niveau afin de distinguer les raccourcis quotidiens des fonctions qui demandent davantage de préparation.

La légende est simple : **Débutant** désigne un usage quotidien, sans risque et fondé sur un concept simple ; **Intermédiaire** signale un prérequis, comme Git ou une configuration, ou un effet notable sur la session ; **Avancé** concerne l'orchestration, le cloud, la performance ou une commande puissante qu'il faut comprendre avant de l'utiliser.

> Repères : **[Skill]** = compétence bundlée · **[Workflow]** = orchestration multi-agents · *(alias)* = raccourci équivalent.

```mermaid
mindmap
  root((Commandes slash))
    Session et contexte
      clear, compact, context
      resume, rewind, fork
    Configuration
      config, model, effort
      sandbox, ide
    Git et revue
      review, autofix-pr
    Agents et orchestration
      plan, workflows, schedule
    Permissions et MCP
      permissions, mcp, hooks
    Skills et plugins
    Aide et divers
      help, doctor, status
```

> 🗒️ **Note de Claude** — Ces commandes de session, je les ressens directement. Quand vous changez de sujet sans `/clear`, je traîne l'ancien contexte et je risque de mélanger deux problèmes ; un `/clear` au bon moment me rend plus net et vous coûte moins de tokens. Même logique avec `/plan` : me laisser cadrer avant d'écrire, c'est m'éviter de refaire le travail à côté.

## Session & contexte

| Commande | Niveau | À quoi ça sert (et quand) |
|---|---|---|
| `/clear` | Débutant | Cette commande vide le contexte et démarre une conversation neuve ; utilisez-la lorsque vous changez de sujet afin d'éviter les mélanges et de réduire le coût en tokens. |
| `/compact` | Débutant | Elle résume la conversation pour libérer de la place tout en conservant le fil, ce qui convient aux longues sessions consacrées au même sujet. |
| `/context` | Intermédiaire | Elle affiche une grille colorée de l'occupation du contexte pour identifier ce qui remplit la fenêtre avant de choisir entre `/compact` et `/clear`. |
| `/branch` | Intermédiaire | Elle crée une bifurcation de la conversation afin d'explorer une piste alternative sans perdre le fil principal. |
| `/fork` | Avancé | Elle lance en arrière-plan un sous-agent qui hérite de toute la conversation, utile pour déléguer en parallèle avec le même contexte sans encombrer la session. |
| `/background` | Avancé | Elle détache la session courante en arrière-plan afin de laisser avancer un travail long tout en reprenant la main. |
| `/focus` | Débutant | Elle affiche une vue épurée limitée au dernier prompt, au résumé et à la réponse, pratique pour travailler sans le bruit de l'historique. |
| `/copy` | Débutant | Elle copie la dernière réponse dans le presse-papier lorsque vous devez la réutiliser ailleurs. |
| `/export` | Débutant | Elle exporte la conversation en texte afin de l'archiver ou de la partager. |
| `/recap` | Débutant | Elle condense la session en cours en une seule ligne pour en retrouver immédiatement le sujet. |
| `/rename` | Débutant | Elle renomme la session afin de pouvoir la reconnaître et la retrouver plus facilement par la suite. |
| `/resume` | Débutant | Elle reprend une conversation existante pour rouvrir un travail entamé *(alias `/continue`)*. |
| `/rewind` | Intermédiaire | Elle revient à un état antérieur ou restaure un instantané pour annuler une série d'actions ou repartir d'un point sûr. |
| `/color` | Débutant | Elle change la couleur de la barre de prompt afin de personnaliser ou de mieux distinguer la session. |
| `/tasks` | Intermédiaire | Elle gère les tâches lancées en arrière-plan pour consulter ou piloter les travaux détachés *(alias `/bashes`)*. |
| `/stop` | Intermédiaire | Elle arrête la session en arrière-plan active lorsqu'elle n'a plus besoin de continuer. |
| `/teleport` | Intermédiaire | Elle récupère une session web dans le terminal pour poursuivre localement un échange commencé en ligne *(alias `/tp`)*. |
| `/desktop` · `/mobile` | Débutant | Ces commandes poursuivent le travail dans l'application desktop ou affichent un QR code pour continuer sur mobile. |

## Configuration & installation

| Commande | Niveau | À quoi ça sert (et quand) |
|---|---|---|
| `/config` | Débutant | Cette commande ouvre les paramètres du modèle, du thème ou de l'affichage ; c'est le point central pour régler Claude Code. |
| `/status` | Débutant | Elle affiche la version, le compte et la connectivité dans l'onglet Status, ce qui en fait le premier réflexe de diagnostic. |
| `/statusline` | Intermédiaire | Elle configure les informations affichées dans la barre de statut située en bas du terminal. |
| `/theme` | Débutant | Elle change le thème de couleur lorsque vous souhaitez adapter la lisibilité ou l'apparence de l'interface. |
| `/tui` | Intermédiaire | Elle choisit le rendu terminal `default` ou `fullscreen`, puis redémarre l'interface ; le plein écran intercepte notamment la souris. |
| `/effort` | Intermédiaire | Elle règle l'effort de raisonnement de `low` à `max`, avec `ultracode`, afin d'arbitrer vitesse et coût contre profondeur d'analyse. |
| `/fast` | Débutant | Elle active ou désactive une sortie plus rapide sans changer de modèle : Claude reste sur Opus 4.8. |
| `/model` | Débutant | Elle change le modèle utilisé et mémorise ce choix pour les sessions suivantes. |
| `/doctor` | Intermédiaire | Elle diagnostique l'installation et recherche les problèmes de configuration ou d'environnement. |
| `/debug` | Avancé | Elle active la journalisation de débogage pour investiguer un dysfonctionnement de l'outil lui-même. |
| `/heapdump` | Avancé | Elle capture un instantané de la mémoire pour mener un diagnostic technique avancé. |
| `/add-dir` · `/cd` | Intermédiaire | Ces commandes ajoutent ou changent le dossier de travail afin de donner accès à un autre répertoire du projet. |
| `/ide` | Intermédiaire | Elle gère les intégrations avec des environnements de développement comme VS Code ou JetBrains. |
| `/chrome` | Intermédiaire | Elle ouvre les réglages de Claude dans Chrome lorsque cette intégration est utilisée. |
| `/terminal-setup` | Débutant | Elle configure les raccourcis du terminal, par exemple `Shift+Entrée` pour insérer un saut de ligne. |
| `/keybindings` | Intermédiaire | Elle édite les raccourcis clavier afin d'adapter les commandes à vos habitudes. |
| `/scroll-speed` | Débutant | Elle règle la vitesse de défilement à la souris pour rendre la navigation plus confortable. |
| `/voice` | Débutant | Elle configure la dictée vocale avec les modes `hold`, `tap` ou `off`. |
| `/sandbox` | Avancé | Elle active ou désactive le mode bac à sable pour fluidifier l'exécution de commandes à risque limité tout en conservant une barrière de sécurité. |
| `/privacy-settings` | Débutant | Elle ouvre les réglages de confidentialité relatifs aux données et à la télémétrie. |

> **Explique plus — le bac à sable.** Un bac à sable est un espace d'exécution isolé : les commandes shell peuvent y tourner sans atteindre le reste du système ni le réseau. Lorsqu'il est actif, Claude peut donc enchaîner des actions sans demander une autorisation à chaque étape, car leurs conséquences restent confinées. Hors bac à sable, les opérations sensibles repassent par une demande de permission. Le gain est surtout pratique sur des tâches bien délimitées, mais l'isolation ne dispense pas de comprendre ce que l'on exécute.

## Git, code & revue

| Commande | Niveau | À quoi ça sert (et quand) |
|---|---|---|
| `/diff` | Débutant | Cette commande affiche les changements non commités pour voir immédiatement les différences entre les fichiers actuels et leur dernière version enregistrée. |
| `/code-review` **[Skill]** | Intermédiaire | Elle relit le diff à la recherche de bugs et de nettoyage utile, avec les options `--fix` et `--comment`, avant de créer un commit. |
| `/security-review` | Intermédiaire | Elle analyse les changements en attente pour détecter notamment des failles ou des secrets exposés. |
| `/review` | Intermédiaire | Elle relit une PR GitHub avec le même moteur que `code-review`, afin d'évaluer les modifications proposées avant leur fusion. |
| `/ultrareview` | Avancé | Elle exécute en sandbox cloud une revue approfondie par plusieurs agents pour auditer exhaustivement une branche ou une PR ; son lancement est volontaire et facturé. |
| `/autofix-pr` | Avancé | Elle surveille une PR en cours et applique au fil de l'eau les corrections demandées par les échecs de CI ou les commentaires de revue. |
| `/simplify` **[Skill]** | Intermédiaire | Elle nettoie le code modifié et applique des corrections destinées à améliorer sa lisibilité. |
| `/run` **[Skill]** | Intermédiaire | Elle lance et pilote l'application du projet pour observer son comportement réel. |
| `/verify` **[Skill]** | Intermédiaire | Elle vérifie qu'un changement produit effectivement le résultat attendu avant de le considérer comme terminé. |
| `/run-skill-generator` **[Skill]** | Avancé | Elle configure une fois pour toutes la manière dont `/run` et `/verify` doivent lancer l'application. |

> **Explique plus — PR, revue et CI.** Une pull request, ou PR, est une demande de fusion d'une branche vers une autre sur une plateforme comme GitHub. L'équipe y examine les modifications avant leur intégration. `/review` effectue cette lecture à un instant donné. `/autofix-pr` va plus loin : Claude reste en veille, observe les nouveaux commentaires et les échecs de CI — les tests automatiques relancés après chaque changement — puis corrige progressivement la PR jusqu'à ce qu'elle soit prête à fusionner.

## Agents & orchestration

| Commande | Niveau | À quoi ça sert (et quand) |
|---|---|---|
| `/agents` | Intermédiaire | Cette commande gère les configurations de sous-agents afin de préparer des exécutants spécialisés pour des tâches précises. |
| `/advisor` | Avancé | Elle sollicite un modèle plus puissant aux moments clés, lorsque la décision à prendre exige une analyse plus difficile. |
| `/deep-research` **[Workflow]** | Avancé | Elle organise une recherche web vérifiée, synthétisée et sourcée par plusieurs agents. |
| `/workflows` | Avancé | Elle suit les workflows en cours et permet de les mettre en pause, de les reprendre ou de les sauvegarder. |
| `/batch` **[Skill]** | Avancé | Elle exécute en parallèle des changements à grande échelle, par exemple une migration répartie sur de nombreux fichiers. |
| `/loop` **[Skill]** | Avancé | Elle relance automatiquement un prompt à intervalle régulier pour une tâche récurrente auto-cadencée. |
| `/schedule` | Avancé | Elle planifie des routines cloud à heures ou fréquences fixes, à la manière de cron *(alias `/routines`)*. |
| `/goal` | Intermédiaire | Elle définit un objectif qui doit être vérifié avant que la tâche puisse être considérée comme terminée. |
| `/plan` | Intermédiaire | Elle bascule en mode plan pour faire concevoir et valider une stratégie avant toute écriture de code, notamment lors d'un changement important. |
| `/ultraplan` | Avancé | Elle rédige un plan, le fait relire dans le navigateur, puis l'exécute. |
| `/remote-control` | Avancé | Elle permet de piloter Claude Code à distance depuis claude.ai *(alias `/rc`)*. |
| `/remote-env` | Avancé | Elle définit l'environnement par défaut utilisé par les agents cloud. |

> **Explique plus — sous-agents et workflows.** Un sous-agent est une autre instance de Claude, lancée pour une mission précise avec son propre contexte. Cette séparation permet de paralléliser plusieurs recherches ou d'isoler une tâche sans encombrer la conversation principale. Un workflow coordonne plusieurs sous-agents selon un déroulement déterminé : répartition du travail, étapes successives et vérification des résultats. Cron désigne, lui, la planification automatique d'une tâche selon un horaire ou une fréquence fixe.
>
> **Explique plus — le mode plan.** Pour un changement conséquent, commencer à modifier les fichiers immédiatement peut conduire à refaire le travail si l'approche était mal cadrée. Avec `/plan`, Claude étudie d'abord le besoin, construit une stratégie et attend sa validation avant d'écrire du code. Le lecteur peut ainsi corriger les hypothèses, le périmètre ou l'ordre des étapes à moindre coût.

## Compte, permissions, MCP, plugins, skills

| Commande | Niveau | À quoi ça sert (et quand) |
|---|---|---|
| `/login` · `/logout` | Débutant | Ces commandes connectent ou déconnectent le compte Anthropic lorsque vous changez d'identité ou de session. |
| `/permissions` | Intermédiaire | Elle règle les règles `allow`, `ask` et `deny` afin de choisir l'équilibre entre autonomie de Claude et contrôle humain. |
| `/mcp` | Intermédiaire | Elle gère les serveurs MCP et permet de les reconnecter, de les activer ou de les désactiver. |
| `/plugin` | Intermédiaire | Elle gère les plugins, notamment leur affichage, leur installation et leur activation. |
| `/reload-plugins` · `/reload-skills` | Intermédiaire | Ces commandes rechargent les plugins ou les skills après leur modification pour rendre les changements disponibles. |
| `/skills` | Intermédiaire | Elle liste les skills disponibles afin de connaître les compétences packagées que Claude peut invoquer. |
| `/memory` | Intermédiaire | Elle édite `CLAUDE.md` et la mémoire automatique pour fournir à Claude des règles persistantes propres au projet. |
| `/hooks` | Avancé | Elle configure des actions déclenchées automatiquement avant ou après certains événements, lorsque l'exécution doit être fiable et déterministe. |
| `/install-github-app` · `/install-slack-app` | Intermédiaire | Ces commandes installent l'application GitHub ou Slack pour activer les intégrations correspondantes. |
| `/web-setup` | Intermédiaire | Elle associe le compte GitHub à Claude Code web afin d'utiliser le service avec ce dépôt. |
| `/setup-bedrock` · `/setup-vertex` | Avancé | Ces commandes configurent l'authentification Amazon Bedrock ou Google Vertex pour faire passer Claude Code par le fournisseur cloud de l'entreprise. |
| `/claude-api` **[Skill]** | Intermédiaire | Elle charge la référence de l'API Claude lorsque vous développez une intégration fondée sur cette API. |
| `/fewer-permission-prompts` **[Skill]** | Avancé | Elle réduit le nombre de demandes de permission ; il faut comprendre ce contrôle cédé avant de l'activer. |

> **Explique plus — MCP.** Le Model Context Protocol est un standard de connexion entre Claude et des outils ou sources de données externes, par exemple un service interne ou un espace Google Drive. Le serveur MCP expose des capacités précises de façon contrôlée ; `/mcp` sert à administrer ces connexions, pas à donner un accès indistinct à toutes les données.
>
> **Explique plus — les hooks.** Un hook signifie « exécuter cette action chaque fois que tel événement survient ». Il peut intervenir avant ou après l'utilisation d'un outil. Comme le harnais déclenche directement cette règle, son exécution est plus fiable et déterministe qu'une simple consigne formulée en langage naturel dans la conversation.
>
> **Explique plus — Bedrock et Vertex.** Amazon Bedrock et Google Vertex sont des plateformes cloud capables d'héberger et de fournir des modèles. Leur configuration intéresse surtout les entreprises qui veulent utiliser Claude Code à travers leur propre fournisseur cloud, avec l'authentification et le cadre d'exploitation correspondants.

## Aide & divers

| Commande | Niveau | À quoi ça sert (et quand) |
|---|---|---|
| `/help` | Débutant | Cette commande affiche l'aide et la liste des commandes ; c'est le point de départ lorsqu'une fonction vous échappe. |
| `/btw` | Débutant | Elle pose une question annexe sans modifier l'historique de travail, comme une parenthèse « by the way ». |
| `/feedback` | Débutant | Elle permet de transmettre un retour, de signaler un bug ou de partager une expérience *(alias `/bug`, `/share`)*. |
| `/init` | Débutant | Elle initialise un guide `CLAUDE.md` pour le projet ; c'est la première action utile sur un nouveau dépôt. |
| `/insights` · `/team-onboarding` | Intermédiaire | Ces commandes produisent un rapport d'analyse ou un guide d'accueil pour aider une équipe à comprendre son environnement de travail. |
| `/usage` | Débutant | Elle affiche les coûts, les limites et l'activité afin de suivre sa consommation *(alias `/cost`, `/stats`)*. |
| `/usage-credits` · `/upgrade` · `/passes` | Débutant | Ces commandes donnent accès aux crédits, à la mise à niveau ou à la semaine offerte selon le besoin du compte. |
| `/release-notes` | Débutant | Elle affiche le journal des nouveautés pour découvrir les changements apportés aux versions récentes. |
| `/powerup` | Débutant | Elle propose de courtes leçons interactives pour apprendre les fonctionnalités de Claude Code. |
| `/stickers` · `/radio` | Débutant | Ces commandes donnent accès aux stickers Claude Code ou à une radio lo-fi pour agrémenter l'environnement. |
| `/exit` | Débutant | Elle quitte l'interface en ligne de commande lorsque la session est terminée *(alias `/quit`)*. |

> **Commandes retirées :** `/vim`, dont le réglage passe désormais par `/config`, et `/pr-comments` ne sont plus disponibles dans les versions récentes.

## Créer ses propres commandes slash

Claude Code permet de transformer une consigne répétitive en commande dédiée. Il suffit de créer un fichier Markdown dans `.claude/commands/` pour une commande liée au projet et partageable avec l'équipe via le dépôt Git, ou dans `~/.claude/commands/` pour une commande personnelle disponible dans tous ses projets.

Le nom du fichier devient celui de la commande : `deploy.md` crée ainsi `/deploy`. Son contenu constitue le prompt exécuté. Il peut recevoir les arguments saisis par l'utilisateur grâce à `$ARGUMENTS` et référencer des fichiers utiles. Ce mécanisme convient à une revue respectant les conventions de l'équipe, à une génération de structure répétitive ou à une checklist. Une longue consigne récurrente devient alors un raccourci cohérent, réutilisable et, dans le dossier du projet, partageable.

## Mécanique du menu `/`

Taper `/` ouvre la palette, puis les premières lettres saisies filtrent immédiatement les propositions. Certaines commandes acceptent un argument après leur nom, comme `/model opus`. La bonne méthode consiste donc à retenir quelques usages fréquents et à explorer la palette pour le reste : mémoriser la liste complète n'apporte aucun avantage.

## FAQ

### `/compact` ou `/clear` ?

`/compact` résume l'historique et préserve le fil : choisissez-le pour prolonger une session déjà longue sur le même sujet. `/clear` vide le contexte et repart de zéro : utilisez-le lorsque le sujet change ou que l'ancien échange risque de brouiller le nouveau.

### `/fast` change-t-il de modèle ?

Non. Il accélère la sortie, mais Claude reste sur Opus 4.8. Pour changer réellement de modèle, utilisez `/model`.

### Comment automatiser une action « à chaque fois que… » ?

Configurez un hook avec `/hooks`. Le harnais déclenche alors l'action sur l'événement prévu, de manière fiable et déterministe, au lieu de dépendre du rappel d'une consigne conversationnelle.

### Skill, Workflow et commande : quelle différence ?

Une commande slash est un raccourci qui déclenche une action ou un prompt. Un **[Skill]** est une compétence packagée, composée d'une procédure et d'instructions que Claude peut invoquer. Un **[Workflow]** orchestre plusieurs sous-agents selon des étapes et des vérifications définies.

### Pourquoi le collage au clic droit ne fonctionne-t-il plus en plein écran ?

Le rendu TUI `fullscreen` intercepte la souris. Revenez au rendu `default` dans `/config` si vous souhaitez retrouver le comportement habituel du terminal pour le collage.

### Où sont passées `/vim` et `/pr-comments` ?

Ces deux commandes ont été retirées des versions récentes. Pour l'ancien réglage associé à `/vim`, passez désormais par `/config` ; `/pr-comments` n'est plus disponible.

## Glossaire

- **PR (pull request)** : demande de fusion des changements d'une branche vers une autre. Elle centralise la revue et la validation avant intégration.
- **Diff** : liste précise des lignes ajoutées, supprimées ou modifiées entre deux états des fichiers.
- **Commit** : enregistrement identifié d'un ensemble de changements dans l'historique Git.
- **Branche** : ligne de travail séparée dans Git, utilisée pour modifier le code sans toucher immédiatement à la version principale.
- **CI (intégration continue)** : automatisation qui lance notamment des tests à chaque changement afin de détecter rapidement les régressions.
- **Contexte / fenêtre de contexte** : quantité limitée d'informations que le modèle peut prendre en compte dans une session, dont la conversation et les contenus chargés.
- **Token** : petite unité de texte traitée par le modèle ; la consommation et la capacité du contexte se mesurent en tokens.
- **Bac à sable (sandbox)** : environnement isolé qui limite l'accès des commandes au système et au réseau afin de contenir leurs effets.
- **Permission** : règle qui autorise, refuse ou soumet à confirmation une action que Claude souhaite exécuter.
- **Hook** : action déclenchée automatiquement lorsqu'un événement défini survient, par exemple avant ou après l'emploi d'un outil.
- **Sous-agent** : instance séparée de Claude chargée d'une mission précise avec son propre contexte.
- **Skill** : compétence packagée qui fournit à Claude une procédure et des instructions spécialisées.
- **Workflow** : orchestration déterministe de plusieurs sous-agents, étapes et contrôles pour atteindre un résultat.
- **MCP** : Model Context Protocol, standard permettant à Claude de se connecter de façon contrôlée à des outils et données externes.
- **Cron** : mécanisme de planification qui exécute automatiquement une tâche selon une heure ou une fréquence définie.
- **Bedrock / Vertex** : plateformes cloud d'Amazon et de Google qui peuvent héberger et fournir des modèles dans un cadre d'entreprise.
- **TUI** : interface utilisateur affichée dans un terminal, avec un mode standard ou plein écran.