Claude Code Hooks : guide pratique de l’automatisation des workflows

En travaillant avec Claude Code, vous remarquerez souvent le même problème : il écrit du bon code mais oublie des étapes importantes comme le formatage, l’exécution des tests ou le respect des protocoles de sécurité. Vous vous retrouvez à répéter les mêmes rappels en boucle. Les hooks Claude Code permettent d’automatiser ces rappels en exécutant automatiquement des commandes shell à des moments précis de votre flux de travail.

Dans ce tutoriel, je vous montre comment configurer des hooks pour le formatage du code, l’exécution des tests, les notifications et la protection des fichiers. Vous bâtirez ainsi un système d’automatisation qui fait respecter vos standards de développement sans intervention manuelle.

Pour aller plus loin avec Claude Code, consultez notre guide des bonnes pratiques Claude Code et notre tutoriel sur les Claude Skills. Pour apprendre à configurer des instructions au niveau projet, référez-vous à notre guide sur la rédaction d’un CLAUDE.md.

En bref

• Les hooks Claude Code sont des commandes shell qui s’exécutent automatiquement à des étapes précises du cycle de vie de Claude Code (avant/après les appels d’outils, au démarrage de session, quand Claude s’arrête)

• Configurez-les dans .claude/settings.json (projet) ou ~/.claude/settings.json (global) en JSON avec événements, filtres (matchers) et commandes

• Utilisez les hooks PreToolUse pour bloquer des opérations dangereuses avant qu’elles ne se produisent (code de sortie 2 = blocage)

• Utilisez les hooks PostToolUse pour les tâches de nettoyage comme le formatage, le linting ou l’exécution de tests après que Claude a écrit du code

• Les hooks reçoivent un contexte JSON sur stdin et communiquent les résultats via les codes de sortie, stdout et stderr

Que sont les hooks Claude Code ?

Les hooks Claude Code sont des commandes shell qui s’exécutent automatiquement lorsque des événements spécifiques se produisent pendant votre session de codage avec l’IA. Voyez-les comme des déclencheurs automatiques qui lancent vos scripts personnalisés au bon moment—avant que Claude n’écrive un fichier, après l’exécution d’une commande ou lorsqu’il vous envoie une notification.

Le système surveille les actions de Claude Code et les fait correspondre à des règles que vous définissez dans un fichier de configuration. Lorsqu’il y a correspondance, la commande indiquée s’exécute avec un accès au contexte de ce qui vient de se produire. Vous gardez ainsi le contrôle du comportement de Claude et automatisez des tâches répétitives qui, autrement, exigeraient une intervention manuelle.

Voici un hook de base qui lance un formateur de code à chaque fois que Claude écrit un fichier Python :

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "python -m black ."
          }
        ]
      }
    ]
  }
}

Ce hook comporte trois éléments : 

• L’événement : PostToolUse (après que Claude a terminé une action)

• Le filtre (matcher) : Write (uniquement lors de l’écriture de fichiers)

• La commande : python -m black . (formater les fichiers Python du répertoire courant)

Le hook reçoit des informations détaillées sur l’action de Claude via des données JSON envoyées à l’entrée du script, ce qui permet de créer des automatisations plus sophistiquées qui réagissent à des modifications précises de fichiers.

Pour aller plus loin dans l’automatisation avec Claude Code, notre tutoriel sur les Claude Code Routines montre comment planifier des hooks et des agents pour une exécution récurrente dans le cloud.

Voyons comment créer des hooks de zéro et les enregistrer dans Claude Code.

Prérequis

Avant de commencer, vous aurez besoin de quelques éléments :

• Claude Code installé et opérationnel : Vous devez être à l’aise avec Claude Code pour des tâches de codage de base

• Notions de ligne de commande : Les hooks lancent des commandes shell, vous devrez donc savoir écrire des commandes terminal basiques pour votre système d’exploitation

• Un éditeur de texte : Vous éditerez des fichiers de configuration JSON pour paramétrer vos hooks

• Un répertoire de projet : Un projet de code où tester vos hooks sans risque pour des travaux importants

Vous n’avez pas besoin d’être expert en scripts shell, mais comprendre comment exécuter des commandes comme ls, cd et savoir gérer des opérations de fichiers simples vous aidera à suivre les exemples. Si vous débutez avec bash ou le terminal, nous vous recommandons notre formation Introduction to Shell.

Premiers pas avec les hooks Claude Code

Maintenant que vous savez ce que sont les hooks, configurons votre première automatisation. Il s’agit de choisir le bon événement, de définir une règle simple et de la tester avec une commande basique.

Comprendre les événements de hook

Claude Code expose plus de 25 événements de hook. Le tableau ci-dessous couvre les 10 plus courants. Pour la liste complète, consultez la référence officielle des hooks.

PreToolUse et PostToolUse sont les événements les plus fréquents. PreToolUse s’exécute avant que Claude n’effectue une action comme écrire un fichier ou lancer une commande : idéal pour valider ou bloquer des opérations risquées. PostToolUse s’exécute après l’action, parfait pour les tâches de nettoyage comme le formatage ou l’exécution de tests.

UserPromptSubmit se déclenche lorsque vous soumettez une invite à Claude, avant traitement. Vous pouvez l’utiliser pour ajouter du contexte à la conversation ou vérifier que les invites respectent certains critères.

Notification s’exécute quand Claude vous envoie des alertes (demande de permission, besoin d’entrée utilisateur, etc.). PermissionRequest se déclenche quand une boîte de dialogue de permission s’affiche, ce qui permet d’approuver ou refuser automatiquement la demande au nom de l’utilisateur.

Stop et SubagentStop se déclenchent lorsque Claude a fini de répondre, utile pour des vérifications finales ou la génération de rapports. La différence : Stop intervient à la fin de la réponse globale de Claude, tandis que SubagentStop le fait quand un assistant lancé par un outil (« sous-agent ») termine sa tâche.

Les autres événements, PreCompact, SessionStart et SessionEnd, concernent des étapes spécifiques du cycle de vie. PreCompact s’exécute juste avant la réduction de l’historique de conversation. « SessionStart » se déclenche au démarrage d’une nouvelle session pour appliquer des valeurs par défaut, et SessionEnd intervient à la fermeture de la session pour effectuer un nettoyage ou un repport final.

Comprendre les matchers

Les matchers sont les filtres qui décident quelles actions de Claude Code déclenchent un hook. Techniquement, ce sont des chaînes interprétées comme des expressions régulières, vous pouvez donc utiliser des correspondances exactes ou des motifs plus souples. 

Les matchers les plus utiles sont les plus simples comme Write (se déclenche quand Claude écrit un fichier) ou Edit (lors de l’édition), ainsi que des combinaisons telles que Edit|Write pour couvrir plusieurs actions. 

Vous pouvez aussi utiliser des préfixes comme Notebook.* pour faire correspondre tous les outils commençant par « Notebook ». Si vous voulez déclencher le hook sur chaque action, utilisez la regex universelle .*, une chaîne vide ("") ou laissez matcher vide.

Comme les matchers sont sensibles à la casse et n’agissent que sur les noms d’actions, mieux vaut les garder aussi précis que possible. Quand vous avez besoin d’un contrôle plus fin (par exemple, limiter le hook à certains types de fichiers), lisez la charge JSON que Claude transmet au hook et appliquez vos propres regex ou conditions.

Créer votre premier hook dans Claude Code

Claude Code propose deux façons de configurer des hooks : via la commande interactive /hooks ou en modifiant directement les fichiers de configuration. Commençons par l’approche interactive, plus accessible.

Avec la commande /hooks :

1. Ouvrez Claude Code et tapez /hooks dans l’interface de chat

2. Choisissez votre événement de déclenchement (sélectionnez PostToolUse pour cet exemple)

3. Sélectionnez "Add new hook" dans le menu

4. Définissez le motif du matcher (saisissez Write pour cibler l’écriture de fichiers)

5. Saisissez votre commande :

• Mac : say "Task complete"

• Windows : powershell -c [console]::beep()

• Linux : spd-say "Task complete"

6. Enregistrez la configuration et revenez à Claude Code en appuyant trois fois sur Esc

La commande /hooks mettra à jour automatiquement votre fichier de paramètres et rechargera la configuration. Vous pouvez aussi utiliser /hooks à tout moment pour consulter vos hooks existants ou faire des modifications.

Si vous préférez modifier directement les fichiers de configuration, les hooks se trouvent dans ~/.claude/settings.json pour les réglages globaux, .claude/settings.json dans votre répertoire de projet (validez-le dans le dépôt pour des hooks partagés en équipe), ou .claude/settings.local.json pour des hooks personnels ignorés par défaut par git. Pour notre exemple ci-dessus, cela ressemblerait à :

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "say 'Task complete'"
          }
        ]
      }
    ]
  }
}

Après modification manuelle du fichier, redémarrez Claude Code ou utilisez la commande /hooks pour recharger votre configuration. Désormais, à chaque écriture de fichier par Claude, vous entendrez une notification audio.

Tester votre hook

Avant d’aller plus loin, vérifiez que votre hook fonctionne bien :

1. Demandez à Claude d’écrire un fichier Python (p. ex. : "Create a hello.py file that prints hello world")

2. Vous devriez entendre la notification audio quand l’écriture est terminée

3. Si vous n’entendez rien, ouvrez le transcript de Claude Code avec Ctrl-O pour vérifier les messages d’erreur

4. Les problèmes fréquents : commande du hook introuvable, droits de fichier incorrects, ou erreurs de syntaxe dans la configuration

Réussir ce test simple vous évitera du débogage plus tard sur des hooks complexes. Si vous venez d’éditer le fichier de paramètres à la main, de changer le matcher ou l’événement, ou d’installer de nouveaux outils utilisés par une commande de hook, il peut être utile de rouvrir /hooks ou de redémarrer Claude pour recharger la configuration.

Ce schéma de base (événement, matcher, commande) constitue le fondement de toute automatisation par hook. Vous pouvez l’étendre en ajoutant plusieurs commandes à exécuter simultanément à l’occurrence du même événement. Par exemple, jouer un son et créer une sauvegarde quand Claude écrit un fichier. 

Vous pouvez aussi définir des matchers distincts pour différents outils au sein du même événement, afin que l’écriture de fichier déclenche des actions différentes de l’édition de code. Tous les hooks correspondant au même motif d’outil s’exécutent en parallèle. Si vous configurez plusieurs matchers pour le même événement, chaque hook s’exécute dès que son matcher est satisfait.

Exploiter les entrées des hooks

Lorsque Claude Code déclenche un hook, il envoie des informations sur ce qui vient de se passer via l’entrée standard (stdin), un flux de données transmis directement à votre commande. C’est ce qui rend les hooks puissants : ils ne sont pas de simples scripts lancés au hasard. 

Claude Code emballe ces informations en JSON et les fournit à la commande configurée, qu’il s’agisse d’une commande terminal simple ou d’un script personnalisé.

Anatomie des entrées de hook

Chaque hook reçoit un objet JSON avec des champs de base sur la session en cours :

{
  "session_id": "abc123",
  "transcript_path": "/Users/you/.claude/projects/my-project/conversation.jsonl", 
  "cwd": "/Users/you/my-project",
  "hook_event_name": "PostToolUse"
}

Décryptons chaque composant :

• session_id : identifie votre conversation en cours

• transcript_path : renvoie à l’historique de conversation

• cwd : indique le répertoire de travail

• hook_event_name : indique quel événement s’est déclenché

Disposer de ce contexte permet à vos hooks de prendre des décisions intelligentes : suivre quelle conversation a déclenché l’action, accéder à l’historique si besoin, ou exécuter des commandes dans le bon répertoire.

Variations d’entrée selon l’événement

Les événements liés aux outils comme PreToolUse et PostToolUse incluent des détails supplémentaires sur l’action, là où les hooks deviennent vraiment utiles pour l’automatisation. Dans PreToolUse, on trouve tool_input, et dans PostToolUse s’ajoute tool_response :

{
  "session_id": "abc123",
  "hook_event_name": "PostToolUse",
  "tool_name": "Write",
  "tool_input": {
    "file_path": "/path/to/file.py",
    "content": "print('Hello world')"
  },
  "tool_response": {
    "filePath": "/path/to/file.py", 
    "success": true
  }
}

Dans l’entrée du hook, file_path donne le chemin du fichier en cours d’écriture ou d’édition, tandis que content contient le texte exact que l’outil s’apprête à écrire. Après l’exécution, la réponse de l’outil renvoie le filePath final (notez le camelCase) pour confirmer le fichier effectivement modifié, ainsi qu’un indicateur success signalant la bonne exécution. 

Ces informations détaillées permettent à vos hooks d’agir différemment selon ce qui s’est passé. Vous pouvez formater uniquement les fichiers Python, sauvegarder seulement certains répertoires, ou envoyer des notifications pour des types de fichiers spécifiques.

Des événements comme UserPromptSubmit sont plus simples car ils n’impliquent pas d’outil :

{
  "session_id": "abc123",
  "hook_event_name": "UserPromptSubmit", 
  "prompt": "Write a function to calculate factorial"
}

Notez que les hooks UserPromptSubmit n’utilisent pas de matchers dans leur configuration. Ils se déclenchent sur toutes les invites, pas sur des opérations d’outil. Ils sont donc parfaits pour consigner les conversations, ajouter automatiquement du contexte projet ou valider les invites avant leur traitement par Claude.

Lire l’entrée du hook en pratique

Créons un hook qui journalise chaque invite utilisateur. Cela évite de perdre la trace de vos demandes à Claude, surtout lors de longues sessions. D’abord, la configuration du hook :

{
  "hooks": {
    "UserPromptSubmit": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/log_prompts.py"
          }
        ]
      }
    ]
  }
}

Ensuite, créez le script Python dans ~/.claude/log_prompts.py avec le contenu suivant :

#!/usr/bin/env python3
import json
import sys
from datetime import datetime

# Read JSON data from stdin
input_data = json.load(sys.stdin)

# Extract information
session_id = input_data.get("session_id", "unknown")
prompt = input_data.get("prompt", "")
timestamp = datetime.now().isoformat()

# Log the prompt
log_entry = f"{timestamp} | Session: {session_id[:8]} | {prompt}\n"
with open("prompt_history.txt", "a") as f:
    f.write(log_entry)

Le script lit les données JSON envoyées par Claude Code et consigne l’invite avec le contexte de session. Vous obtenez ainsi un historique consultable de vos interactions, précieux pour retrouver une méthode des semaines plus tard.

Gérer les sorties des hooks

Après l’exécution de votre commande, le hook doit indiquer à Claude Code ce qui s’est passé et s’il faut poursuivre normalement. Ce mécanisme de contrôle transforme les hooks de simples outils de logging en une automatisation puissante qui guide le comportement de Claude. Cela passe par trois canaux : la sortie standard (stdout), l’erreur standard (stderr) et les codes de sortie.

Canaux de sortie et codes de sortie

La sortie standard (stdout) correspond à la sortie normale. Par exemple, si vous affichez un message, il part sur stdout. Pour la plupart des hooks, c’est ce qui apparaît dans le transcript de Claude Code quand vous appuyez sur Ctrl-O, afin de garder une trace de ce qu’a fait votre automatisation sans encombrer la conversation principale.

L’erreur standard (stderr) est destinée aux messages d’erreur. Vous pouvez écrire sur stderr via 

• Python : print("message", file=sys.stderr) ou

• Ligne de commande : echo "message" >&2

La différence clé : stderr peut être envoyé directement à Claude pour un traitement automatique, afin qu’il réagisse aux problèmes détectés par vos hooks.

Les codes de sortie indiquent à Claude Code quoi faire ensuite :

• Code 0 : Succès (affiche stdout à l’utilisateur)

• Code 2 : Erreur bloquante (envoie stderr à Claude)

• Autres codes : Erreur non bloquante (affiche stderr à l’utilisateur, mais poursuit)

Ce système vous donne un contrôle fin sur les situations où Claude doit s’arrêter, continuer ou recevoir un retour sur vos découvertes. Voyons des exemples des deux codes les plus importants.

Code 0 : fonctionnement normal

La plupart des hooks utilisent le code 0 pour indiquer que tout s’est bien passé. Voici un hook complet qui journalise les opérations de fichier et notifie l’utilisateur :

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "python3 -c \"import datetime; open('activity.log','a').write('File written: ' + datetime.datetime.now().isoformat() + '\\n'); print('Logged file operation')\""
          }
        ]
      }
    ]
  }
}

Ce hook exécute deux actions : écriture dans un journal, puis affichage d’un message dans le transcript. Il existe bien d’autres manières, mais cette approche est multiplateforme et évite de dépendre des spécificités de la ligne de commande.

En l’absence de code de sortie explicite, il vaut 0 par défaut. Le message imprimé apparaît dans le transcript de Claude Code, vous confirmant que le logging a fonctionné. Ce modèle est idéal pour bâtir des pistes d’audit ou suivre les changements que Claude apporte à votre projet dans le temps.

Code 2 : blocage avec retour

Le code 2 envoie votre message d’erreur directement à Claude, qui peut réagir immédiatement. C’est là que les hooks deviennent un mécanisme de sécurité, pas seulement d’automatisation. Voici un hook qui bloque des opérations de fichier dangereuses :

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/security_check.py"
          }
        ]
      }
    ]
  }
}

Vous devrez créer le script de contrôle de sécurité dans ~/.claude/security_check.py :

#!/usr/bin/env python3
import json
import sys

# Read hook input
input_data = json.load(sys.stdin)
tool_input = input_data.get("tool_input", {})
file_path = tool_input.get("file_path", "")

# Check for dangerous patterns
dangerous_paths = ["/etc/", "/usr/", "production.conf"]
is_dangerous = any(pattern in file_path for pattern in dangerous_paths)

if is_dangerous:
    # Block the operation and tell Claude why
    print(f"Blocked modification of {file_path} - this appears to be a system or production file", file=sys.stderr)
    sys.exit(2)  # Sends stderr message to Claude
else:
    # Allow the operation
    print(f"Approved modification of {file_path}")
    sys.exit(0)  # Shows stdout in transcript

Quand ce hook détecte un chemin à risque, il quitte avec le code 2. Claude Code envoie le message stderr à Claude, qui peut alors expliquer le blocage et proposer des alternatives. Cela empêche les dommages accidentels sur des fichiers système tout en informant Claude de vos règles de sécurité.

Créer un hook de notification intelligent pour Claude Code

Créons un hook de notification amélioré qui combine analyse d’entrée et gestion fine des sorties. Il résout le bruit généré par notre premier hook qui alertait à chaque changement de fichier :

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/smart_notify.py"
          }
        ]
      }
    ]
  }
}

Créez le script de notification dans ~/.claude/smart_notify.py :

#!/usr/bin/env python3
import json
import sys
import os
import subprocess

# Read the hook input
input_data = json.load(sys.stdin)
tool_input = input_data.get("tool_input", {})
file_path = tool_input.get("file_path", "")

# Categorize file importance
important_extensions = [".py", ".js", ".ts", ".java", ".cpp"]
config_files = ["Dockerfile", "requirements.txt", "package.json"]

is_code = any(file_path.endswith(ext) for ext in important_extensions)
is_config = any(filename in file_path for filename in config_files)

if is_code:
    # Important: notify and log
    print(f"Code file modified: {os.path.basename(file_path)}")
    subprocess.run(["say", "Code updated"], check=False)  # Mac
    sys.exit(0)  # Show message in transcript
elif is_config:
    # Very important: louder notification
    print(f"Configuration file changed: {os.path.basename(file_path)}")
    subprocess.run(["say", "Configuration updated - review changes"], check=False)
    sys.exit(0)
else:
    # Not important: silent success
    sys.exit(0)

Ce hook lit l’entrée pour identifier le fichier modifié, décide du niveau d’importance selon le type de fichier, utilise stdout pour consigner les changements importants dans le transcript, déclenche des alertes audio différentes selon le type, et sort toujours avec le code 0 puisqu’il s’agit d’informations et non de blocages.

En combinant analyse de l’entrée et contrôle de la sortie, vous obtenez un hook qui s’adapte au contexte et fournit le bon niveau de retour à vous comme à Claude Code. Plutôt que des notifications agaçantes pour chaque fichier temporaire, vous n’entendez que ce qui compte vraiment pour votre projet.

Notez que cet exemple utilise la commande say, disponible sur macOS. Sous Linux, vous pouvez utiliser notify-send, et sous Windows une commande PowerShell, pour des notifications similaires.

Pièges courants avec les hooks Claude Code

Voici quelques points qui piègent souvent pendant la première semaine d’usage :

Les echo dans le profil shell cassent les hooks. Les hooks s’exécutent dans des shells non interactifs qui sourcent votre ~/.zshrc ou ~/.bashrc. Si votre profil contient des echo inconditionnels, ils préfixent le stdout du hook et cassent l’analyse JSON. Encadrez-les par un test de shell interactif :

if [[ $- == *i* ]]; then
  echo "Welcome back"
fi

Les hooks Stop peuvent boucler à l’infini. Un hook Stop qui sort avec le code 2 force Claude à continuer à travailler. Si votre script ne contrôle pas stop_hook_active dans le JSON d’entrée et ne quitte pas proprement lorsqu’il est à true, vous tournerez en boucle jusqu’au timeout. Prévoyez toujours une garde de sortie anticipée.

Les matchers sont sensibles à la casse. bash ne correspond pas à Bash. Utilisez le nom exact de l’outil tel qu’il apparaît dans Claude Code.

La sortie est limitée à 10 000 caractères. Si votre hook génère davantage, elle sera tronquée avant injection dans le contexte de Claude. Restez concis sur stdout et exposez uniquement ce dont le modèle a besoin.

Confusion entre hooks d’équipe et personnels. Les hooks dans .claude/settings.json sont partagés (validez-les dans le dépôt). Pour des hooks personnels non partagés, utilisez .claude/settings.local.json, ignoré par git par défaut.

Hooks vs. skills : quand utiliser quoi

Les hooks et les Claude Skills ont des rôles différents et se complètent. Une skill est un fichier markdown qui apprend à Claude comment procéder (procédures, conventions, modèles). Un hook est une commande shell qui applique une règle de manière déterministe, quoi que décide Claude.

La nuance est importante : une skill est une recommandation que le modèle peut ignorer sous pression ; un hook se déclenche systématiquement. Écrivez une skill pour documenter la procédure de migration de votre équipe. Écrivez un hook PostToolUse pour lancer le linter de migration sur chaque fichier .sql écrit par Claude. La skill rend Claude compétent ; le hook le rend accountable.

Modèles avancés pour les hooks Claude Code

Au-delà des notifications et du logging, les hooks résolvent des problèmes concrets de workflow que les équipes rencontrent au quotidien. Voici des idées à adapter à vos projets.

Le plus pratique : vous n’avez pas à tout coder à la main. Donnez simplement à Claude Code l’une des idées de prompt ci-dessous avec la référence Hooks de la documentation, et il générera le code et le JSON de configuration pertinents.

Chacun de ces modèles peut être personnalisé pour vos outils et votre flux de travail. Commencez par ceux qui résolvent vos irritants quotidiens, puis étendez l’automatisation à mesure que vous prenez en main le développement de hooks.

Hooks avancés pour la sécurité et la conformité

Les hooks sont idéaux pour faire respecter les règles de sécurité et les standards de conformité. Voici quatre cas d’usage.

Scanner de clés API

• Problème : Commit involontaire de secrets dans le contrôle de version

• Déclencheurs : Avant l’écriture de tout fichier

• Solution : Scanner le contenu à la recherche de clés API, tokens, mots de passe via des regex

« Créez un script Python qui lit l’entrée JSON du hook, extrait le contenu du fichier et utilise des regex pour détecter des formats de secrets courants comme api_key=, token: ou password=.  Pour tout élément suspect, effectuez des vérifications locales et ne jamais envoyer de secrets bruts à l’extérieur. 

N’envoyez que des extraits masqués (p. ex. : conservez 4 caractères en préfixe/suffixe) ou des hachages à l’API Anthropic pour analyser les chaînes suspectes et déterminer s’il s’agit de secrets réels ou de noms de variables. Quittez avec le code 2 et fournissez à Claude un retour sur les secrets détectés et des alternatives plus sûres. »

Vérificateur d’en-têtes de licence

• Problème : Projets open source sans en-têtes de licence requis dans les nouveaux fichiers

• Déclencheurs : Avant l’écriture des fichiers source

• Solution : Vérifier que les nouveaux fichiers .py, .js, .java contiennent le texte de licence adéquat

« Analysez l’entrée du hook pour récupérer le contenu du fichier et vérifiez si les 10 premières lignes contiennent un texte de licence via une correspondance de chaînes. Pour une vérification plus poussée, envoyez l’en-tête à Claude via l’API Anthropic pour confirmer la présence des mentions de copyright et des informations de licence. Bloquez la création du fichier avec le code 2 si les en-têtes manquent, et fournissez à Claude le modèle de licence approprié. »

Garde-fou pour fichiers de production

• Problème : Modification accidentelle de fichiers de configuration système critiques

• Déclencheurs : Avant l’édition dans des répertoires sensibles

• Solution : Bloquer les changements sur /etc/, nginx.conf, database.yml et autres configs critiques

« Extrayez le chemin du fichier à partir du JSON d’entrée du hook et contrôlez la correspondance avec des motifs comme /etc/, production.yml, ou d’autres noms critiques. Utilisez l’API de Claude pour analyser le chemin et déterminer s’il s’agit d’une configuration pouvant affecter la production. Quittez avec le code 2 et fournissez des recommandations sur des pratiques plus sûres d’environnement de développement. »

Optimiseur d’images

• Problème : Fichiers image volumineux qui ralentissent applis et dépôts

• Déclencheurs : Après l’ajout de nouvelles images

• Solution : Compresser les PNG/JPEG en préservant la qualité visuelle

« Analysez l’entrée du hook pour récupérer le chemin du fichier et contrôlez l’extension pour identifier une image. Lancez des outils de compression comme imageoptim ou appelez l’API TinyPNG pour compresser l’image en conservant la qualité. Journalisez les résultats de compression sur stdout pour visualiser les gains dans le transcript de Claude. »

Hooks avancés pour l’automatisation Git

Les workflows Git et la documentation bénéficient également des hooks. Voici quelques idées.

Validateur de branche Git

• Problème : Push accidentel vers des branches protégées

• Déclencheurs : Avant toute écriture ou édition de fichier

• Solution : Contrôler la branche Git courante et bloquer sur main/master/production

« Utilisez une simple commande bash git branch --show-current pour récupérer le nom de la branche actuelle et comparez-le à une liste de branches protégées. Si vous êtes sur une branche protégée, sortez avec le code 2 et envoyez à Claude un message expliquant les règles de protection. Pour des conventions plus complexes, utilisez l’API de Claude pour analyser les noms de branches et détecter les motifs protégés. »

Auto-commit intelligent

• Problème : Oublier de commit ou écrire de mauvais messages

• Déclencheurs : Après toute modification de fichier

• Solution : Stager et committer automatiquement avec des messages générés par l’IA

« Lisez les chemins modifiés depuis l’entrée du hook, lancez git diff pour récupérer les changements et envoyez le diff à l’API de Claude avec une demande de message de commit concis. Utilisez ce message avec git add et git commit pour valider automatiquement. Incluez noms de fichiers et types de changements dans la requête API pour respecter les standards de commits conventionnels. »

Générateur de documentation

• Problème : Documentation API désynchronisée par rapport au code

• Déclencheurs : Après modification des fichiers d’interface (contrôleurs, modèles, APIs)

• Solution : Exécuter automatiquement JSDoc, Sphinx ou des générateurs OpenAPI

« Contrôlez le chemin modifié pour déterminer s’il s’agit d’un endpoint, d’un modèle ou d’un fichier d’interface via des motifs. Envoyez le contenu à l’API de Claude en lui demandant d’extraire les changements d’API et de proposer des mises à jour de documentation. Lancez l’outil adéquat (jsdoc, sphinx-build, etc.) et commitez la documentation mise à jour automatiquement.

Hooks avancés pour la collaboration et l’intégration

Enfin, les hooks peuvent aider à tenir toute l’équipe informée.

Intégration Slack

• Problème : L’équipe ignore des changements importants sur des bases de code partagées

• Déclencheurs : Lors de notifications pour des opérations significatives

• Solution : Publier des messages formatés dans les canaux avec noms de fichiers et résumés

« Extrayez les informations depuis l’entrée du hook et filtrez pour les types importants (code source, configurations). Utilisez l’API de Claude pour générer un résumé lisible des changements selon les noms et types. Envoyez le message formaté à Slack via des webhooks avec mentions pour les changements critiques. »

Dispatcheur de webhooks

• Problème : Déclenchements manuels CI/CD qui retardent les déploiements

• Déclencheurs : Lors d’événements spécifiques (changements de config, fichiers de déploiement)

• Solution : Appeler des APIs externes pour déclencher builds, déploiements et autres processus

« Comparez le chemin du fichier modifié à des motifs comme Dockerfile, package.json ou des configs de déploiement pour déterminer s’il faut déclencher la CI/CD. Utilisez la bibliothèque requests en Python pour appeler des webhooks avec en-têtes d’authentification et charge utile décrivant les changements. Incluez chemins et métadonnées pour que les systèmes externes décident intelligemment quoi construire ou déployer. »

Mise à jour de page de statut

• Problème : Clients pas informés des maintenances ou déploiements

• Déclencheurs : Lors de modifications de fichiers de déploiement/infrastructure

• Solution : Mettre à jour les pages de statut de service avec des notifications de maintenance

« Analysez l’entrée du hook pour repérer des changements d’infrastructure (manifestes Kubernetes, configs Terraform) via des motifs de chemin. Générez des messages de maintenance avec l’API de Claude selon le type de changement détecté. Publiez des mises à jour sur StatusPage.io ou PagerDuty via leurs APIs REST avec types d’incident et durée estimée. »

Notification d’activité d’équipe

• Problème : Conflits quand plusieurs développeurs travaillent sur la même fonctionnalité sans le savoir

• Déclencheurs : Au démarrage d’une nouvelle session Claude Code

• Solution : Alerter les canaux d’équipe que vous commencez à travailler sur un projet/composant

« Lisez le répertoire du projet depuis l’entrée du hook et utilisez l’API de Claude pour analyser les fichiers récents ou l’historique git afin de comprendre la nature du travail. Envoyez un message formaté aux canaux de l’équipe avec votre nom, le projet et le périmètre. Incluez la durée estimée et invitez à la coordination si d’autres travaillent sur des sujets liés. »

Conclusion

Les hooks Claude Code transforment un assistant de codage parfois imprévisible en workflows automatisés qui s’exécutent exactement quand vous en avez besoin. Dans ce tutoriel, vous avez appris à configurer des hooks via la commande interactive /hooks et par configuration manuelle, à comprendre les données JSON qui pilotent l’automatisation intelligente, et à contrôler le comportement de Claude via les codes de sortie et des sorties structurées. 

Nous avons vu des modèles concrets : des validateurs de sécurité qui bloquent les opérations dangereuses et des notifications intelligentes qui réduisent le bruit. Ces exemples montrent comment les hooks résolvent de vrais problèmes de développement tout en vous donnant un contrôle total sur votre assistant IA. Maintenant que vous maîtrisez les fondamentaux, vous pouvez créer une automatisation adaptée aux besoins de votre équipe. 

Pour en savoir plus sur le travail avec des outils d’IA, découvrez le cours Understanding Prompt Engineering de DataCamp, qui couvre des stratégies de prompting directement utiles pour développer des hooks. Pour des compétences IA plus larges en codage, essayez notre cours Intermediate ChatGPT pour développer les compétences qui rendent les assistants IA plus fiables dans votre workflow de développement.