# Aide-mémoire Claude Code

Hiérarchie CLAUDE.md, settings.json, permissions, hooks, Skills, commandes, subagents, mode plan, mode headless, config MCP et commandes de session.

import { Steps } from '@prosefly/astro-components';

## Hiérarchie de configuration

```text
Precedence (highest → lowest)
┌──────────────────────────────────────────────────────────┐
│ Managed / enterprise policy   (IT-controlled, cannot be   │
│                                overridden by users)       │
├──────────────────────────────────────────────────────────┤
│ Command-line flags            (--model, --allowedTools…)  │
├──────────────────────────────────────────────────────────┤
│ .claude/settings.local.json   (project, git-ignored)      │
├──────────────────────────────────────────────────────────┤
│ .claude/settings.json         (project, checked in)       │
├──────────────────────────────────────────────────────────┤
│ ~/.claude/settings.json       (user)                      │
└──────────────────────────────────────────────────────────┘

CLAUDE.md memory (all loaded, most specific wins on conflict)
  managed policy CLAUDE.md → ~/.claude/CLAUDE.md → ./CLAUDE.md → ./sub/dir/CLAUDE.md
  CLAUDE.local.md = personal, git-ignored        @path/to/file = import
```

### Quoi va où

| Contenu | Placez-le dans |
| --- | --- |
| Règles de sécurité à l'échelle de l'org, commandes interdites | `settings.json` de la politique gérée |
| Conventions du dépôt : commandes build/test, architecture, style | `./CLAUDE.md` (versionné, concis) |
| Guidage spécifique à un module | `./module/CLAUDE.md` |
| Raccourcis personnels, chemins locaux | `~/.claude/CLAUDE.md` ou `CLAUDE.local.md` |
| Longs documents de référence | Fichier séparé, `@import`-ez-le ou faites-en un Skill |
| Procédure multi-étapes réutilisable | Skill (`.claude/skills/<name>/SKILL.md`) |
| Ligne unique paramétrée | Slash command (`.claude/commands/<name>.md`) |
| Tâche déléguée nécessitant un contexte/des outils isolés | Subagent (`.claude/agents/<name>.md`) |
| Accès à un système externe | Serveur MCP (`.mcp.json`) |
| Règle dure qui ne doit jamais être enfreinte | Hook (déterministe) — jamais juste une phrase dans CLAUDE.md |

## Exemple de CLAUDE.md

```markdown
# Project: payments-api

## Commands
- Install: `pnpm install`  · Test: `pnpm test`  · Lint: `pnpm lint`  · Typecheck: `pnpm tsc --noEmit`

## Architecture
- Hexagonal: `src/domain` (pure), `src/adapters` (IO). Never import adapters from domain.
- All money values are integer minor units (cents). Never floats.

## Workflow
- Run `pnpm test` before proposing a commit. Use conventional commits.
- Prefer plan mode for changes touching more than 3 files.

@docs/api-conventions.md
```

## settings.json

```json
{
  "model": "claude-opus-5",
  "permissions": {
    "allow": ["Read", "Edit", "Bash(pnpm test*)", "Bash(pnpm lint*)", "Bash(git status*)", "Bash(git diff*)"],
    "ask":   ["Bash(git commit*)", "Bash(git push*)", "WebFetch"],
    "deny":  ["Bash(rm -rf*)", "Bash(git push --force*)", "Read(.env*)", "Read(**/secrets/**)"]
  },
  "env": { "NODE_ENV": "test" },
  "hooks": {
    "PreToolUse": [{
      "matcher": "Bash",
      "hooks": [{ "type": "command", "command": ".claude/hooks/guard.sh" }]
    }],
    "PostToolUse": [{
      "matcher": "Edit|Write",
      "hooks": [{ "type": "command", "command": "pnpm lint --fix $CLAUDE_FILE_PATHS" }]
    }]
  }
}
```

## Hooks

| Événement | Se déclenche | Usage typique |
| --- | --- | --- |
| `SessionStart` | Session nouvelle/reprise | Charger l'env, afficher le statut |
| `UserPromptSubmit` | Avant le traitement du prompt | Injecter du contexte, bloquer les prompts interdits |
| `PreToolUse` | Avant l'exécution d'un outil | **Bloquer** les commandes destructives, appliquer la politique |
| `PostToolUse` | Après le succès d'un outil | Lint/format, lancer les tests, journaliser |
| `Notification` | Claude a besoin d'attention | Ping desktop/Slack |
| `Stop` | L'agent principal termine | Vérifier que les tests ont tourné ; imposer « avez-vous lancé les tests ? » |
| `SubagentStop` | Un subagent termine | Agréger les résultats |
| `PreCompact` | Avant la compaction | Persister l'état critique dans des fichiers/la mémoire |

Contrat de hook : reçoit du JSON sur stdin (nom d'outil, entrée, id de session) ; **exit 0** = autoriser, **exit 2** = bloquer et renvoyer stderr à Claude ; autre non-zéro = erreur non bloquante. Peut aussi émettre du JSON sur stdout pour des décisions structurées.

```bash
#!/usr/bin/env bash
# .claude/hooks/guard.sh – block destructive shell
cmd=$(jq -r '.tool_input.command // empty')
if echo "$cmd" | grep -Eq 'rm -rf|git push --force|drop table|mkfs|dd if='; then
  echo "Blocked by policy: destructive command" >&2
  exit 2
fi
exit 0
```

## Skills

```text
.claude/skills/release-notes/
└── SKILL.md
```

```markdown
---
name: release-notes
description: Generate release notes from merged PRs since the last tag. Use when asked for a changelog or release summary.
---
1. Run `git describe --tags --abbrev=0` to find the last tag.
2. List merged PRs since then with `gh pr list --state merged --search "merged:>$TAG_DATE"`.
3. Group by label (feat, fix, chore) and write Markdown under `## vNEXT`.
```

Les Skills se chargent **progressivement** : seuls le nom/la description sont en contexte jusqu'à ce que Claude juge le skill pertinent. Préférez les Skills à l'alourdissement de CLAUDE.md.

## Slash commands personnalisées

```markdown
<!-- .claude/commands/review.md -->
Review the diff in $ARGUMENTS for security issues (injection, secrets, authz), then correctness, then style.
Output a table: severity | file:line | issue | fix.
```

Invocation : `/review src/payments/`.

## Subagents

```markdown
<!-- .claude/agents/security-reviewer.md -->
---
name: security-reviewer
description: Reviews code changes for security vulnerabilities. Use proactively after edits to auth or payment code.
tools: Read, Grep, Glob
model: claude-sonnet-5
---
You are a security reviewer. Report only findings with file:line, severity and fix. Do not edit files.
```

- Fenêtre de contexte isolée ; reçoit **uniquement** ce que le parent transmet explicitement.
- Allowlist d'outils et modèle propres (modèle moins cher pour les tâches mécaniques).
- Gérez avec `/agents`.

## Mode plan vs direct

| Choisissez le mode plan quand | Choisissez le direct quand |
| --- | --- |
| Changement multi-fichiers ou architectural | Édition mono-fichier, évidente |
| Base de code inconnue | Zone bien comprise |
| Opérations irréversibles impliquées | Lecture seule ou trivialement réversible |
| Vous voulez relire avant l'exécution | La vitesse compte et le risque est faible |

Basculez avec Shift+Tab ; le mode plan est en lecture seule jusqu'à votre approbation.

## Headless / CI

```bash
# JSON result for scripting
claude -p "Summarise failing tests in $(cat test.log)" --output-format json

# Streaming JSON events
claude -p "Review this PR" --output-format stream-json

# Restrict tools and permission mode
claude -p "Fix lint errors" --allowedTools "Read,Edit,Bash(pnpm lint*)" --permission-mode acceptEdits

# Resume a session
claude --resume <session-id>
```

| `--permission-mode` | Comportement |
| --- | --- |
| `default` | Demander selon la politique |
| `acceptEdits` | Auto-accepter les éditions de fichiers, demander pour le shell |
| `plan` | Plan uniquement |
| `bypassPermissions` | Aucune invite — CI sandboxé uniquement |

Les codes de sortie font remonter les échecs au CI ; parsez `--output-format json` pour le résultat et `usage`.

## Configuration MCP

```bash
claude mcp add github -- npx -y @modelcontextprotocol/server-github      # local stdio, scope local
claude mcp add --scope project docs -- python mcp_docs_server.py         # writes .mcp.json
claude mcp add --transport http linear https://mcp.linear.app/mcp        # remote Streamable HTTP
claude mcp list
```

```json
// .mcp.json (project scope, checked in)
{ "mcpServers": {
  "docs":   { "command": "python", "args": ["mcp_docs_server.py"], "env": { "DOCS_ROOT": "./docs" } },
  "linear": { "type": "http", "url": "https://mcp.linear.app/mcp" }
} }
```

| Scope | Où | Partagé ? |
| --- | --- | --- |
| `local` | `~/.claude.json` sous le chemin du projet | Non |
| `project` | `.mcp.json` dans le dépôt | Oui (versionné) |
| `user` | `~/.claude.json` | Sur l'ensemble de vos projets |

## Tableau de décision de configuration

| Vous devez… | Mécanisme | Pas ceci |
| --- | --- | --- |
| Énoncer les conventions du dépôt (build/test/style) | `./CLAUDE.md` (concis, versionné) | Un long README que le modèle doit relire |
| Imposer une règle qui ne doit jamais casser | **Hook** (PreToolUse, exit 2) | Une phrase dans CLAUDE.md (prompt-comme-application) |
| Empaqueter une procédure multi-étapes réutilisable | Skill (`SKILL.md`) | Alourdir CLAUDE.md |
| Fournir une ligne unique paramétrée | Slash command (`$ARGUMENTS`) | Un Skill (excessif) |
| Déléguer une tâche isolée avec ses propres outils | Subagent (`.claude/agents`) | L'exécuter dans le contexte principal |
| Connecter un système externe | Serveur MCP (`.mcp.json`) | Un outil sur mesure par application |
| Interdictions à l'échelle de l'org que les utilisateurs ne peuvent pas outrepasser | Settings de politique gérée | Settings de projet (outrepassables) |
| Chemins/raccourcis locaux personnels | `CLAUDE.local.md` / `~/.claude` | Fichiers de projet versionnés |

:::tip[Signal d’examen]
« L'équipe continue d'exécuter une commande interdite bien que CLAUDE.md dise de ne pas le faire » → la solution est un **hook PreToolUse** (déterministe, exit 2), pas une phrase plus ferme. Le prompt-comme-application est l'anti-pattern 3.
:::

## Exemples détaillés de préséance

```text
Scenario A – model conflict
  managed policy: model = claude-sonnet-5   (locked)
  ~/.claude/settings.json: model = claude-opus-5
  --model claude-haiku-4-5 on the CLI
  → Effective: claude-sonnet-5   (managed policy wins over everything)

Scenario B – permission conflict
  project .claude/settings.json allow: Bash(git push*)
  managed policy deny: Bash(git push --force*)
  → git push allowed; git push --force denied (deny in a higher scope wins)

Scenario C – CLAUDE.md conflict
  ./CLAUDE.md: "use tabs"
  ./frontend/CLAUDE.md: "use 2-space indent"
  → In frontend/, 2-space wins (most specific file wins on conflict; both are loaded)
```

## Codes de sortie et payload des hooks

```text
stdin (JSON):  { "tool_name": "Bash", "tool_input": { "command": "…" }, "session_id": "…", "cwd": "…" }

exit 0  → allow (stdout may carry structured JSON decision)
exit 2  → BLOCK; stderr is fed back to Claude as the reason
other   → non-blocking error (logged, action proceeds)
```

| Événement | Peut bloquer ? | Usage typique |
| --- | --- | --- |
| `SessionStart` | Non | Charger l'env, afficher le statut |
| `UserPromptSubmit` | Oui | Injecter du contexte ; rejeter les prompts interdits |
| `PreToolUse` | **Oui** | Bloquer les commandes destructives, appliquer la politique |
| `PostToolUse` | Non | Lint/format, lancer les tests, journaliser |
| `Stop` | Oui | Imposer « les tests ont-ils tourné ? » avant de finir |
| `SubagentStop` | Oui | Agréger/valider la sortie du subagent |
| `PreCompact` | Non | Persister l'état critique avant le résumé |
| `Notification` | Non | Ping desktop/Slack |

```json
// Structured stdout decision (alternative to exit code)
{ "decision": "block", "reason": "Migrations require review", "continue": false }
```

## Référence complète des champs de settings.json

| Champ | Objet |
| --- | --- |
| `model` | Modèle par défaut de la session |
| `permissions.allow / ask / deny` | Règles outils/commandes par motif ; `deny` dans un scope supérieur l'emporte |
| `permissions.additionalDirectories` | Répertoires supplémentaires accessibles à la session |
| `env` | Variables d'environnement injectées dans les exécutions d'outils |
| `hooks` | Handlers événement → matcher → commande |
| `enableAllProjectMcpServers` | Auto-approuver les serveurs `.mcp.json` |
| `enabledMcpjsonServers` / `disabledMcpjsonServers` | Autoriser/refuser des serveurs MCP de projet spécifiques |
| `cleanupPeriodDays` | Rétention des transcripts |
| `includeCoAuthoredBy` | Activer/désactiver le trailer git de co-auteur Claude |

## Motifs de permission

```json
{ "permissions": {
  "allow": ["Read", "Edit", "Bash(pnpm test:*)", "Bash(git status)", "Bash(git diff:*)"],
  "ask":   ["Bash(git commit:*)", "Bash(git push:*)", "WebFetch(domain:docs.internal)"],
  "deny":  ["Bash(rm -rf:*)", "Bash(curl:*)", "Read(./.env)", "Read(./**/*.pem)", "Read(**/secrets/**)"]
} }
```

- Les motifs sont préfixe + glob ; `:*` correspond aux arguments. Soyez précis — `Bash(git:*)` est plus large que vous ne le pensez.
- Les fichiers de secrets vont dans `deny` **et** dans `.gitignore` ; ne comptez jamais sur le modèle pour les éviter.
- `deny` l'emporte sur `allow`/`ask` ; un `deny` de scope supérieur l'emporte sur un `allow` de scope inférieur.

## Politique gérée pour les équipes

L'IT livre un `settings.json` géré (macOS `/Library/Application Support/ClaudeCode/managed-settings.json` ; Linux `/etc/claude-code/`) que les utilisateurs **ne peuvent pas** outrepasser :

```json
{ "permissions": {
    "deny": ["Bash(rm -rf:*)", "Bash(git push --force:*)", "Read(**/*.pem)", "WebFetch"] },
  "model": "claude-sonnet-5",
  "disabledMcpjsonServers": ["*"] }
```

Utilisez-le pour les interdictions à l'échelle de l'org, un modèle par défaut approuvé, et la désactivation par défaut des serveurs MCP de projet non fiables. C'est l'endroit correct pour l'examen pour « doit s'appliquer à tous quelle que soit la config locale ».

## Idées reçues courantes

| Idée reçue | Réalité | Pourquoi cela compte à l'examen |
| --- | --- | --- |
| « CLAUDE.md peut imposer une règle dure » | Seul un hook applique de façon déterministe | Anti-pattern du prompt-comme-application |
| « Le `--model` du CLI l'emporte toujours » | La politique gérée outrepasse les flags CLI | Distracteur de préséance |
| « `/compact` et `/clear` sont pareils » | `/compact` réduit la *même* conversation ; `/clear` repart de zéro (garde la mémoire) | Confondre les deux perd du contexte |
| « Les subagents héritent du contexte du parent » | Ils ne reçoivent que ce que le parent transmet explicitement | Distracteur de perte de contexte silencieuse |
| « Plus d'outils = agent plus capable » | 4–8 outils ciblés ; au-delà de ~10 utilisez la recherche d'outils | Anti-pattern de trop d'outils |
| « Le mode plan n'est qu'un mode normal plus lent » | Il est en lecture seule jusqu'à votre approbation du plan | Distracteur aveugle au risque |
| « `.env` est sûr parce que le modèle est prudent » | Ajoutez-le à `deny` et à `.gitignore` | Distracteur de fuite de secret |

## Analyse de scénario

Une équipe de 30 ingénieurs veut standardiser Claude Code : personne ne peut force-push ni lire de secrets, chacun a Sonnet 5 par défaut, les conventions build/test du dépôt sont toujours connues, une revue de sécurité doit tourner après les changements d'auth, et les tests doivent avoir tourné avant que Claude ne se déclare terminé.

<Steps>
1. **Interdictions de force-push / de lecture des secrets pour tous** → liste `deny` du `settings.json` de politique gérée (les utilisateurs ne peuvent pas l'outrepasser). Les settings de projet sont le distracteur — ils sont outrepassables.
2. **Modèle par défaut** → politique gérée `model: claude-sonnet-5`.
3. **Conventions build/test toujours connues** → `./CLAUDE.md` versionné (concis), pas une page wiki.
4. **Revue de sécurité après les changements d'auth** → un **subagent** `security-reviewer` invoqué proactivement, plus un `/security-review` en CI. Un rappel dans CLAUDE.md est le distracteur du prompt-comme-application.
5. **Les tests doivent avoir tourné avant de finir** → un **hook Stop** qui vérifie que les tests ont tourné et bloque (exit 2) sinon — déterministe, pas une phrase de prompt.
6. **Déploiement d'équipe** → distribuez commandes/agents/hooks/MCP sous forme de **plugin** ; onboardez avec un guide généré.
</Steps>

Alternatives rejetées : placer les interdictions dans les settings de projet (outrepassables), imposer « lancer les tests » via la prose de CLAUDE.md (prompt-comme-application), et charger une douzaine d'outils MCP d'emblée (trop d'outils).

## Référence complète des commandes

Toutes les commandes intégrées, skills fournis et workflows fournis disponibles dans une session Claude Code (tapez `/` pour filtrer). `<arg>` = requis, `[arg]` = optionnel. La disponibilité varie selon la plateforme, le plan et le fournisseur — par exemple `/design`, `/artifacts`, `/import` et `/design-sync` sont indisponibles sur Bedrock / Vertex / Foundry, et `/upgrade` n'apparaît pas sur les plans Enterprise. **Skill** = un prompt fourni remis à Claude ; **Workflow** = un workflow dynamique fourni qui se déploie sur des subagents.

### Session, contexte et mémoire

| Commande | Objet |
| --- | --- |
| `/init` | Générer un `CLAUDE.md` de départ ; propose d'`/import` la config Codex ou Gemini CLI si trouvée |
| `/memory` | Éditer les fichiers `CLAUDE.md`, basculer la mémoire auto, voir les entrées d'auto-mémoire |
| `/context [all]` | Visualiser l'usage du contexte sous forme de grille avec suggestions d'optimisation ; `all` déplie la ventilation par élément |
| `/compact [instructions]` | Résumer la conversation pour libérer du contexte ; instructions de focus optionnelles |
| `/autocompact [auto\|<tokens>]` | Régler à quel point la fenêtre se remplit avant la compaction automatique (p. ex. `500k`) |
| `/clear [name]` | Démarrer une conversation fraîche (garde la mémoire du projet) ; label optionnel pour le sélecteur `/resume`. Alias `/reset`, `/new` |
| `/resume [session]` | Reprendre une conversation par ID ou nom, ou ouvrir le sélecteur. Alias `/continue` |
| `/branch [name]` | Bifurquer la conversation actuelle pour essayer une autre direction ; revenez avec `/resume` |
| `/fork [prompt]` | Copier la conversation dans une nouvelle session d'arrière-plan et continuer ici |
| `/subtask <task>` | Lancer un subagent bifurqué qui hérite de la conversation ; le résultat revient ici |
| `/rewind` | Ramener la conversation et/ou le code à un point de contrôle, ou résumer depuis un message. Alias `/checkpoint`, `/undo` |
| `/rename [name]` | Nommer la session (auto-généré depuis l'historique si omis) |
| `/recap` | Résumé sur une ligne de la session actuelle |
| `/btw [question]` | Question annexe qui n'entre pas dans l'historique de la conversation |
| `/export [filename]` | Exporter la conversation en texte brut |
| `/copy [N]` | Copier la dernière réponse assistant (ou la N-ième plus récente) ; sélecteur pour les blocs de code |
| `/cd <path>` | Déplacer la session vers un autre répertoire de travail, en gardant la conversation |
| `/add-dir <path>` | Accorder l'accès fichier à un répertoire supplémentaire pour cette session |
| `/goal [condition\|clear]` | Fixer un objectif vers lequel Claude continue de travailler à travers les tours jusqu'à ce qu'il soit atteint |
| `/exit` | Quitter le CLI (se détache si attaché à une session d'arrière-plan). Alias `/quit` |

### Modèle, effort et vitesse

| Commande | Objet |
| --- | --- |
| `/model [model]` | Changer de modèle (et l'enregistrer par défaut) ; `s` dans le sélecteur change pour cette session uniquement |
| `/effort [level\|auto\|status]` | Régler l'effort `low` … `xhigh`, `max`, `ultracode`, ou `auto` |
| `/fast [on\|off]` | Basculer le mode rapide |
| `/advisor [model\|off]` | Consulter un second modèle (`fable`, `opus`, `sonnet`, ou un ID) aux moments clés |
| `/plan [description]` | Entrer en mode plan, en démarrant optionnellement sur une tâche |

### Permissions, sécurité et configuration

| Commande | Objet |
| --- | --- |
| `/permissions` | Gérer les règles allow / ask / deny par scope, les répertoires de travail, les refus du mode auto. Alias `/allowed-tools` |
| `/fewer-permission-prompts` | **Skill.** Analyser les transcripts pour les appels en lecture seule courants et ajouter une allowlist aux settings de projet |
| `/auto-mode-setup` | Rédiger des entrées `autoMode.environment` depuis votre projet et vos sessions récentes |
| `/sandbox` | Basculer le mode sandbox (plateformes supportées) |
| `/config [key=value …]` | Ouvrir les Settings, ou définir des clés directement (`/config model=sonnet`, `/config thinking=false`). Alias `/settings` |
| `/hooks` | Voir les configurations de hooks |
| `/privacy-settings` | Voir/mettre à jour les paramètres de confidentialité (Pro/Max) |
| `/keybindings` | Ouvrir le fichier des raccourcis clavier |
| `/terminal-setup` | Installer le binding retour à la ligne Shift+Enter (VS Code, Cursor, Zed, Alacritty, …) |
| `/theme` | Changer de thème de couleurs (auto, clair/sombre, daltonisé, ANSI, personnalisé) |
| `/color [color\|default]` | Colorer la barre de prompt pour cette session |
| `/statusline` | Configurer la ligne de statut |
| `/tui [default\|fullscreen]` | Changer le renderer du terminal |
| `/focus` | Basculer la vue focus (renderer plein écran uniquement) |
| `/scroll-speed` | Ajuster la vitesse de défilement à la molette (renderer plein écran) |
| `/vim` | Retiré en v2.1.92 — utilisez `/config` → mode Éditeur |

### Skills, agents, plugins, MCP et workflows

| Commande | Objet |
| --- | --- |
| `/skills` | Lister les skills ; filtrer, trier par coût en tokens, cycler la visibilité |
| `/skill-doctor` | Montrer ce que chaque skill coûte en contexte et sa fréquence d'usage |
| `/reload-skills` | Re-scanner les répertoires de skills et de commandes sans redémarrer |
| `/agents` | Rappel de demander à Claude de créer/gérer les subagents (éditez `.claude/agents/` directement) |
| `/list-agents` | Lister les subagents, coéquipiers d'agent-team et autres sessions que Claude peut contacter. Alias `/peers` |
| `/tasks` | Voir et gérer le travail en arrière-plan dans cette session. Alias `/bashes` |
| `/background [prompt]` | Détacher la session pour l'exécuter comme agent d'arrière-plan. Alias `/bg` |
| `/stop` | Arrêter la session d'arrière-plan attachée (transcript conservé) |
| `/plugin [subcommand]` | Gérer les plugins (`list`, `install`, `enable`, `disable`) |
| `/reload-plugins [--force]` | Recharger les plugins actifs sans redémarrer |
| `/mcp [reconnect <server>\|enable\|disable [<server>\|all]]` | Gérer les connexions MCP et OAuth |
| `/workflows` | Observer, mettre en pause, reprendre ou enregistrer des workflows dynamiques |
| `/workflow-authoring` | **Skill.** Charger la référence pour écrire des scripts de workflow dynamique |
| `/schedule [description]` | Créer/mettre à jour/lister/exécuter des routines cloud. Alias `/routines` |
| `/loop [interval] [prompt]` | **Skill.** Exécuter un prompt de façon répétée tant que la session est ouverte (`/loop 5m check the deploy`). Alias `/proactive` |
| `/batch <instruction>` | **Skill.** Décomposer un grand changement en 5–30 unités, un subagent d'arrière-plan par unité dans son propre worktree, chacun ouvrant une PR |
| `/deep-research <question>` | **Workflow.** Déployer des recherches web, croiser les sources, synthétiser un rapport cité |

### Revue de code, vérification et livraison

| Commande | Objet |
| --- | --- |
| `/diff` | Relire les changements du working-tree y compris les éditions de Claude |
| `/code-review [low\|medium\|high\|xhigh\|max\|ultra] [--fix] [--comment] [pr#\|branch\|path]` | **Skill.** Relire le diff ou une PR pour les bugs de correction ; `--fix` applique, `--comment` publie, `ultra` lance une revue multi-agent cloud. Alias `/review` |
| `/security-review` | Analyser le diff de la branche pour les vulnérabilités de sécurité (injection, auth, exposition de données) |
| `/simplify [target]` | **Skill.** Quatre agents parallèles proposent et appliquent des nettoyages (réutilisation, simplification, efficacité, niveau d'abstraction) |
| `/ultrareview [PR or branch]` | Revue cloud multi-agent approfondie (alias de `/code-review ultra`) |
| `/verify` | **Skill.** Builder, exécuter et observer l'application pour confirmer qu'un changement fonctionne |
| `/run` | **Skill.** Lancer et piloter l'application du projet |
| `/run-skill-generator` | **Skill.** Apprendre à `/run` et `/verify` comment builder et lancer votre application |
| `/autofix-pr [prompt]` | Lancer une session cloud qui surveille la PR de la branche et pousse des correctifs sur échec CI ou commentaires de revue |
| `/pr-comments [PR]` | Retiré en v2.1.91 — demandez directement à Claude |

### Skills Claude API et design

| Commande | Objet |
| --- | --- |
| `/claude-api [migrate\|upgrade\|managed-agents-onboard\|prompt-audit\|cost-optimize\|build-eval\|hillclimb]` | **Skill.** Charger la référence Claude API / Managed Agents ; `migrate` vers un modèle plus récent, `upgrade` la version majeure du SDK, `prompt-audit` les instructions héritées, `cost-optimize` les dépenses, `build-eval` un jeu d'eval, `hillclimb` face à celui-ci |
| `/dataviz [request]` | **Skill.** Guidage de conception de graphiques/dashboards avec palettes adaptées au daltonisme |
| `/design [brief]` | **Skill.** Ébaucher des maquettes UI comme artboards publiés en artifact (API Anthropic uniquement) |
| `/design-sync [hint]` | **Skill.** Uploader le design system React de votre dépôt vers Claude Design |
| `/design-login` | Autoriser l'accès au design system pour `/design-sync` |
| `/artifacts` | Lister, attacher, ouvrir ou copier des artifacts |

### Diagnostics, usage et retours

| Commande | Objet |
| --- | --- |
| `/status` | Settings → onglet Status : version, modèle, compte, connectivité, type de session |
| `/usage` | Coût de session, limites d'usage du plan, statistiques d'activité. Alias `/cost`, `/stats` |
| `/usage-credits` | Configurer ou demander des crédits d'usage quand une limite est atteinte (anciennement `/extra-usage`) |
| `/rate-limit-options` | Façons de continuer à travailler quand une limite claude.ai bloque une requête (masqué ; tapez en entier) |
| `/insights` | Rapport HTML analysant vos sessions récentes |
| `/doctor` | **Skill.** Bilan de configuration : installations, PATH, settings non parsables, skills/MCP/plugins inutilisés, hooks lents, allègement de CLAUDE.md. Alias `/checkup` |
| `/debug [description]` | **Skill.** Activer le logging de debug et diagnostiquer depuis le log de session |
| `/heapdump` | Écrire un snapshot du tas pour les problèmes de mémoire (masqué ; tapez en entier) |
| `/bug [report]` | Signaler un bug / partager la conversation avec consentement. Alias `/share` |
| `/feedback [report]` | Envoyer un retour produit (les brouillons se mettent en file quand le feedback rédigé par Claude est activé) |
| `/release-notes` | Parcourir le changelog par version |
| `/help` | Afficher l'aide et les commandes disponibles |
| `/powerup` | Leçons interactives sur les fonctionnalités |

### Comptes, intégrations et surfaces

| Commande | Objet |
| --- | --- |
| `/login` / `/logout` | Se connecter / déconnecter de votre compte Anthropic |
| `/upgrade` | Ouvrir la page de mise à niveau du plan |
| `/passes` | Partager une semaine gratuite de Claude Code (comptes éligibles) |
| `/stickers` | Commander des stickers |
| `/radio` | Ouvrir la radio lo-fi Claude FM |
| `/ide` | Gérer les intégrations IDE |
| `/chrome` | Configurer Claude dans Chrome |
| `/desktop` | Continuer la session dans l'application Claude Code Desktop. Alias `/app` |
| `/mobile` | QR code pour l'application mobile. Alias `/ios`, `/android` |
| `/voice [hold\|tap\|off]` | Dictée vocale |
| `/remote-control` | Rendre cette session contrôlable depuis claude.ai. Alias `/rc` |
| `/teleport` | Rapatrier une session Claude Code sur le web dans ce terminal. Alias `/tp` |
| `/remote-env` | Choisir l'environnement par défaut des agents cloud |
| `/web-setup` | Connecter GitHub à Claude Code sur le web via les identifiants `gh` locaux |
| `/install-github-app` | Installer la Claude GitHub App (github.com uniquement) et les workflows Actions optionnels |
| `/install-slack-app` | Installer l'application Claude Slack |
| `/import [codex\|gemini\|cursor] [--dry-run] [--yes]` | Importer les fichiers d'instructions, serveurs MCP, commandes, subagents et skills d'autres outils |
| `/team-onboarding` | Générer un guide d'onboarding d'équipe à partir de 30 jours d'usage |
| `/setup-bedrock` / `/setup-vertex` | Assistants de configuration de fournisseur (masqués jusqu'à `CLAUDE_CODE_USE_BEDROCK=1` / `CLAUDE_CODE_USE_VERTEX=1`) |
| `/ultraplan <prompt>` | Retiré — utilisez le mode plan |

:::tip[Signal d’examen]
Commandes les plus susceptibles d'apparaître dans les énoncés d'examen : `/init`, `/memory`, `/compact` vs `/clear`, `/context`, `/plan`, `/model`, `/effort`, `/permissions`, `/hooks`, `/mcp`, `/agents`, `/skills`, `/cost`, `/rewind`, `/code-review`, `/security-review`, `/doctor`. Connaissez la différence entre `/compact` (garder la conversation, la réduire) et `/clear` (conversation fraîche, garder la mémoire), et entre `/branch` (basculer dans une copie), `/fork` (la copie tourne en arrière-plan) et `/subtask` (subagent bifurqué dont le résultat revient).
:::

## Patterns de mise à l'échelle

| Besoin | Utiliser |
| --- | --- |
| Quelques tâches déléguées par tour | Subagents / forks |
| Des dizaines–centaines d'agents coordonnés | Workflows dynamiques (scriptés) |
| Rôles nommés collaborant sur une tâche | Agent teams |
| Jobs récurrents planifiés | Routines |
| Distribuer commandes/agents/hooks/MCP | Plugins |