✦Le Guide Claude
← Tous les chapitresHooks et slash commands Claude Code, automatiser ton terminal en 12 minutes

Partie 11 · Claude qui agit pour toi

Hooks et slash commands Claude Code, automatiser ton terminal en 12 minutes

Tu sauras créer un hook qui bloque les commandes dangereuses, et une slash command qui sauve tes prompts répétés.

Par Ismael Alaoui — 31 mai 2026

Au bout de quelques jours avec Claude Code, tu finis par retaper les mêmes demandes et par répéter les mêmes vérifications à la main. Deux mécanismes officiels existent justement pour automatiser ces réflexes une fois pour toutes.

Avec les hooks, tu peux déclencher du code à des moments précis du cycle de vie d'une session (avant un outil, après une commande, à la fermeture).

Avec les slash commands, tu peux sauvegarder un prompt complet et l'invoquer en tapant simplement une slash command comme /nom.

En 12 minutes de lecture, tu comprends les 25 événements du cycle de vie auxquels tu peux brancher un hook, tu sais écrire ton premier hook qui bloque une commande dangereuse, et tu sais convertir un prompt récurrent en slash command réutilisable.

Ce guide s'adresse à toute personne qui utilise déjà Claude Code et qui veut commencer à le personnaliser.

Tu lis le chapitre 64 d'un manuel de 67 chapitres disponible sur claude-pour-les-debutants.fr.

Ce qu'est un hook

Pour comprendre les hooks, tu peux les voir comme des déclencheurs automatiques qu'Anthropic exécute à des moments précis pendant qu'une session Claude Code tourne.

Tu peux brancher un hook sur 25 événements différents.

Tu peux faire 5 choses différentes en réponse (lancer une commande shell, appeler un endpoint HTTP, invoquer un outil MCP, envoyer un prompt à Claude pour évaluation, spawner un subagent).

Tu peux décider d'autoriser ou de bloquer l'action en cours selon le résultat du hook.

✦ Tu obtiens un mécanisme défensif pour empêcher Claude d'exécuter des commandes destructives.

✦ Tu obtiens un mécanisme d'audit pour logguer ce que Claude fait à des moments clés.

✦ Tu obtiens un mécanisme d'intégration pour notifier d'autres systèmes externes.

→ Tu transformes Claude Code d'un assistant générique en un terminal qui respecte tes règles précises.

Le parcours d'une slash command, du raccourci tapé aux actions lancées

Les 7 événements les plus utiles

Pour cibler les bons événements, tu peux te concentrer sur 7 cas typiques au démarrage.

▸ Tu utilises SessionStart quand tu veux charger un contexte automatiquement au début de chaque conversation (par exemple injecter le contenu d'un fichier de règles).

▸ Tu utilises UserPromptSubmit quand tu veux modifier ou bloquer un prompt avant que Claude le traite (par exemple bloquer les questions qui contiennent un mot interdit).

▸ Tu utilises PreToolUse quand tu veux contrôler ou bloquer un outil avant son exécution (par exemple refuser un rm -rf).

▸ Tu utilises PostToolUse quand tu veux logguer ou alerter après l'exécution d'un outil.

▸ Tu utilises Stop quand tu veux empêcher Claude de terminer sans avoir fait une vérification finale.

▸ Tu utilises SubagentStart et SubagentStop quand tu veux suivre l'activité des subagents.

▸ Tu utilises SessionEnd quand tu veux faire un cleanup ou un commit automatique à la fin de la session.

↳ Tu trouves la liste complète des 25 événements dans la doc officielle hooks.

Frise des sept moments d'une séance où un hook peut se déclencher

Où ranger tes hooks

Tu disposes de 5 emplacements possibles selon le scope souhaité.

Emplacement Scope Partageable
~/.claude/settings.json Tous tes projets Non, local
.claude/settings.json Un seul projet Oui, commit
.claude/settings.local.json Un seul projet Non, gitignore
Managed policy settings Toute l'organisation Oui, admin
Plugin hooks/hooks.json Quand le plugin est activé Oui, bundle

Tu peux aussi définir un hook directement dans le frontmatter d'un skill ou d'un agent. Le hook reste actif tant que le composant tourne.

Ton premier hook qui bloque rm -rf

Pour illustrer comment écrire un hook, tu peux protéger ton repo contre les commandes destructives en quelques lignes.

Tu commences par ajouter le hook à ton ~/.claude/settings.json.

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "if": "Bash(rm *)",
            "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/block-rm.sh",
            "args": []
          }
        ]
      }
    ]
  }
}

Tu crées ensuite le script block-rm.sh dans ton dossier .claude/hooks/.

#!/bin/bash
COMMAND=$(jq -r '.tool_input.command')
if echo "$COMMAND" | grep -q 'rm -rf'; then
  jq -n '{
    hookSpecificOutput: {
      hookEventName: "PreToolUse",
      permissionDecision: "deny",
      permissionDecisionReason: "Destructive command blocked by hook"
    }
  }'
else
  exit 0
fi

Tu rends le script exécutable avec chmod +x .claude/hooks/block-rm.sh. À partir de maintenant, dès que Claude essaie d'exécuter une commande Bash qui contient rm -rf, le hook intercepte la requête et la refuse.

→ Tu peux étendre cette logique à n'importe quel pattern dangereux (git push --force, DROP TABLE, etc.).

Les 5 types de hook

Tu disposes de 5 types selon ce que tu veux faire en réponse à l'événement.

▸ Type command : tu lances un script shell qui reçoit l'événement en JSON sur stdin.

▸ Type http : tu envoies l'événement à un endpoint HTTP en POST.

▸ Type mcp_tool : tu appelles un outil exposé par un serveur MCP (Model Context Protocol, c'est en gros un standard de connecteur entre agents IA et services externes).

▸ Type prompt : tu envoies un prompt à Claude pour qu'il évalue l'événement et te renvoie une décision.

▸ Type agent : tu spawnes un subagent qui vérifie des conditions complexes.

↳ Tu démarres avec le type command pour la majorité des cas, et tu passes au type prompt ou agent quand la décision nécessite du raisonnement.

Les exit codes qui bloquent

Pour signaler à Claude Code que ton hook a bloqué une action, tu peux utiliser le code de sortie 2.

▸ Quand ton hook retourne exit 0, l'action passe normalement et stdout est lu pour récupérer du JSON optionnel.

▸ Quand ton hook retourne exit 2 sur un événement bloquant, l'action est refusée et stderr est renvoyé à Claude comme message d'erreur.

▸ Quand ton hook retourne un autre code (1, 3, etc.), c'est traité comme une erreur non bloquante pour la majorité des événements.

Les événements qui acceptent un blocage par exit 2 sont nombreux : PreToolUse, PermissionRequest, UserPromptSubmit, UserPromptExpansion, Stop, SubagentStop, TeammateIdle, TaskCreated, TaskCompleted, ConfigChange, et PostToolBatch.

Comparaison des codes de sortie exit 0 qui passe, exit 2 qui bloque et les autres codes

Ce qu'est une slash command

Pour comprendre les slash commands, tu peux les voir comme des prompts sauvegardés que tu invoques en tapant /nom.

Quand tu te retrouves à copier-coller la même checklist ou le même prompt dans Claude Code plusieurs fois par semaine, tu transformes ça en slash command. Tu écris une fois le prompt dans un fichier, et tu l'invoques ensuite avec /mon-prompt.

✦ Tu gagnes du temps sur les tâches répétitives.

✦ Tu standardises ton workflow entre projets (le même prompt produit la même qualité).

✦ Tu partages tes slash commands avec ton équipe via le repo.

→ Anthropic a fusionné en 2026 les anciennes "custom commands" avec les "skills". Tu obtiens le même comportement avec les deux formats.

La structure d'un skill (la version moderne)

Pour créer ta première slash command, tu peux écrire un fichier SKILL.md avec un frontmatter et un prompt.

---
name: review-pr
description: Review une pull request pour correctness, style, et sécurité
allowed-tools: [Read, Grep, Glob, Bash(git diff *), Bash(gh pr *)]
model: sonnet
---

# Review PR

Tu vas reviewer la pull request courante. Tu vérifies trois axes 
dans cet ordre :

1. Correctness : le code fait-il ce qu'il prétend faire ?
2. Style : le code respecte-t-il les conventions du projet ?
3. Sécurité : y a-t-il des secrets en dur ou des injections possibles ?

Tu rends ton rapport en 3 sections avec des bullets cliquables 
vers les fichiers concernés.

Tu ranges ce fichier dans .claude/skills/review-pr/SKILL.md (pour un skill projet) ou dans ~/.claude/skills/review-pr/SKILL.md (pour un skill utilisateur global). Tu invoques ensuite la slash command en tapant /review-pr dans ton terminal Claude Code.

Fichier d'une slash command annoté ligne par ligne avec sa légende

Skill vs custom command

Tu peux te demander quelle différence il y a entre une slash command à l'ancienne et un skill moderne.

Tu peux créer /deploy avec un fichier .claude/commands/deploy.md ou avec un skill .claude/skills/deploy/SKILL.md. Les deux formats sont équivalents pour les cas simples.

Tu peux garder tes anciens fichiers .claude/commands/, ils sont toujours valides.

Le skill ajoute trois fonctionnalités optionnelles que la commande seule n'a pas. Tu peux mettre des fichiers de support à côté (templates, scripts auxiliaires).

Tu peux ajouter du frontmatter pour contrôler si c'est toi ou Claude qui invoque le skill (invocation manuelle, automatique, ou les deux). Tu peux laisser Claude charger le skill automatiquement quand il sent qu'il est pertinent.

→ Tu utilises le format skill pour les nouveaux développements, et tu gardes le format commands pour la rétrocompatibilité.

Le menu /hooks et /skills

Tu peux inspecter ce que tu as configuré directement depuis ton terminal.

Tu tapes /hooks dans Claude Code pour ouvrir un browser read-only qui liste tous les hooks configurés. Tu vois pour chaque événement les matchers actifs, et tu vois la source de chaque hook (User, Project, Local, Plugin, Session, ou Built-in).

Tu tapes /skills pour voir la liste des skills disponibles (built-in + tes propres skills + skills installés via plugins). Tu vois la description de chacun, et tu peux invoquer directement depuis ce menu.

↳ Tu désactives tous tes hooks d'un coup avec "disableAllHooks": true dans le settings.json (utile pour debug ou pour comparer un comportement avec/sans hooks).

Un dernier mot

Tu n'as pas besoin de hooks ni de slash commands pour utiliser Claude Code au quotidien.

Tu sors les hooks le jour où tu te dis "j'aimerais que Claude ne fasse jamais X". Tu sors les slash commands le jour où tu te dis "j'écris ce prompt pour la 5e fois cette semaine".

Tu commences toujours par une configuration simple (un hook PreToolUse Bash qui bloque une commande, un skill SKILL.md qui sauve un prompt), et tu étends quand tu vois les limites.

Tu peux estimer qu'un utilisateur Claude Code moyen de 2026 vit avec 5 à 10 hooks et 10 à 20 skills personnalisés.

→ Essaie Claude maintenant : claude.ai

→ Chapitre suivant : API Claude, Console et Workbench pour démarrer

Ce chapitre t'a aidé ?

Sois le premier à donner ton avis.

← Revenir au sommaire du manuel