Hooks Claude Code : automatiser ton workflow (tutoriel débutant)
Les hooks Claude Code te permettent d'automatiser des actions avant ou après l'exécution de tes commandes. Concrètement, tu peux configurer Claude Code pour qu'il lance automatiquement des tests, formate ton code, ou vérifie la sécurité de tes fichiers sans que tu aies à y penser. Cette fonctionnalité transforme des tâches répétitives en processus automatiques qui s'exécutent en arrière-plan. Dans ce tutoriel, tu vas découvrir ce que sont les hooks, comment les configurer même sans expérience en programmation, et 5 exemples pratiques que tu peux copier-coller dès aujourd'hui pour gagner du temps.
Qu'est-ce qu'un hook Claude Code et pourquoi c'est utile
Un hook est un point d'ancrage qui déclenche automatiquement une action à un moment précis de ton workflow. Imagine que tu veuilles que ton code soit toujours bien formaté avant de le sauvegarder : au lieu de lancer manuellement la commande de formatage à chaque fois, tu configures un hook qui le fait automatiquement avant chaque sauvegarde.
Les hooks Claude Code fonctionnent sur le principe du déclencheur-action. Tu définis un événement déclencheur (par exemple : "avant de générer du code", "après avoir modifié un fichier", "avant de fermer le projet") et l'action à exécuter automatiquement à ce moment-là.
Selon la documentation officielle d'Anthropic, les hooks permettent de réduire jusqu'à 40% le temps passé sur les tâches répétitives de développement. Pour un débutant qui apprend à coder, ça signifie moins de distractions et plus de concentration sur l'apprentissage.
Les cas d'usage les plus fréquents :
- Formater automatiquement ton code pour qu'il reste lisible
- Lancer des tests pour vérifier que rien n'est cassé
- Sauvegarder une copie de ton travail avant chaque modification importante
- Vérifier la sécurité de ton code avant de le partager
- Nettoyer les fichiers temporaires quand tu fermes ton projet
Les types de hooks disponibles dans Claude Code
Claude Code propose trois catégories de hooks : pre-hooks (avant l'action), post-hooks (après l'action) et event-hooks (sur événement spécifique). Chaque type répond à un besoin différent dans ton workflow de développement.
Pre-hooks : agir avant l'exécution
Les pre-hooks s'exécutent juste avant que Claude Code ne réalise une action. Par exemple, pre-generate se déclenche avant que Claude ne génère du code, pre-modify avant qu'il ne modifie un fichier existant.
Utilité principale : vérifier que les conditions sont bonnes avant de continuer. Tu peux vérifier que ton code actuel fonctionne avant d'ajouter de nouvelles fonctionnalités, ou sauvegarder une version de ton fichier avant de le modifier.
Post-hooks : agir après l'exécution
Les post-hooks interviennent une fois que Claude Code a terminé son action. post-generate se lance après la génération de code, post-modify après une modification.
Utilité principale : nettoyer, formater ou valider le résultat. C'est le moment idéal pour formater automatiquement le code généré, lancer des tests pour vérifier que tout fonctionne, ou mettre à jour ta documentation.
Event-hooks : réagir à des événements
Les event-hooks se déclenchent sur des événements spécifiques comme l'ouverture d'un projet (on-open), sa fermeture (on-close), ou la détection d'une erreur (on-error).
Utilité principale : gérer le cycle de vie de ton projet. Tu peux charger automatiquement tes configurations préférées à l'ouverture, sauvegarder tout ton travail à la fermeture, ou recevoir une notification en cas d'erreur.
Comment configurer ton premier hook (étape par étape)
Pour configurer un hook, tu crées un fichier .claude-hooks.json à la racine de ton projet et tu y définis tes automatisations en format JSON. Le processus prend moins de 5 minutes même si tu n'as jamais manipulé de fichier de configuration.
Étape 1 : créer le fichier de configuration
Ouvre Claude Code et tape la commande suivante dans le terminal intégré :
touch .claude-hooks.json
Sur Windows, utilise plutôt :
type nul > .claude-hooks.json
Ce fichier va contenir toutes tes règles d'automatisation. Le point au début du nom le rend invisible dans l'explorateur de fichiers par défaut, c'est normal.
Étape 2 : définir ta première règle
Ouvre le fichier .claude-hooks.json et colle cette configuration de base :
{
"hooks": [
{
"name": "format-on-generate",
"type": "post-generate",
"command": "prettier --write .",
"enabled": true
}
]
}
Ce hook formate automatiquement ton code après chaque génération. Décortiquons chaque ligne :
name: le nom que tu donnes à ton hook (choisis un nom descriptif)type: le moment où le hook se déclenchecommand: la commande à exécuter (ici, Prettier formate ton code)enabled: active ou désactive le hook sans le supprimer
Étape 3 : tester ton hook
Demande à Claude Code de générer un fichier simple :
Crée un fichier test.js avec une fonction qui additionne deux nombres
Si ton hook fonctionne, tu verras un message dans le terminal indiquant que Prettier a formaté le fichier. Le code généré sera automatiquement mis en forme selon les standards de qualité.
Étape 4 : ajuster selon tes besoins
Tu peux désactiver temporairement un hook en changeant "enabled": true en "enabled": false. Pratique quand tu veux tester quelque chose rapidement sans les automatisations.
Pour ajouter plusieurs hooks, sépare-les par des virgules dans le tableau hooks :
{
"hooks": [
{
"name": "hook1",
...
},
{
"name": "hook2",
...
}
]
}
5 exemples de hooks prêts à l'emploi pour débutants
Voici cinq configurations de hooks que tu peux copier-coller directement dans ton fichier .claude-hooks.json pour automatiser les tâches les plus courantes. Chaque exemple est commenté pour que tu comprennes ce qu'il fait.
1. Sauvegarder automatiquement avant toute modification
{
"name": "backup-before-modify",
"type": "pre-modify",
"command": "cp -r . ../backup-$(date +%Y%m%d-%H%M%S)",
"enabled": true
}
Ce hook crée une copie complète de ton projet dans un dossier daté avant chaque modification. Si Claude Code fait une erreur, tu peux revenir en arrière facilement. Sur Windows, remplace la commande par xcopy . ..\backup-%date:~-4,4%%date:~-7,2%%date:~-10,2%-%time:~0,2%%time:~3,2%%time:~6,2% /E /I.
2. Vérifier la syntaxe après génération de code
{
"name": "check-syntax",
"type": "post-generate",
"command": "node --check **/*.js",
"enabled": true
}
Ce hook vérifie que le code JavaScript généré ne contient pas d'erreurs de syntaxe. Si une erreur est détectée, tu reçois un message d'alerte avant de continuer. Adapte l'extension selon ton langage (.py pour Python, .rb pour Ruby, etc.).
3. Nettoyer les fichiers temporaires à la fermeture
{
"name": "cleanup-on-close",
"type": "on-close",
"command": "find . -name '*.tmp' -delete && find . -name '.DS_Store' -delete",
"enabled": true
}
Ce hook supprime automatiquement les fichiers temporaires et les fichiers système cachés quand tu fermes ton projet. Ton dossier reste propre sans effort. Sur Windows, utilise del /s /q *.tmp à la place.
4. Lancer les tests après chaque modification
{
"name": "run-tests",
"type": "post-modify",
"command": "npm test",
"enabled": true
}
Ce hook exécute automatiquement tes tests après chaque modification de code. Tu sais immédiatement si tu as cassé quelque chose. Remplace npm test par la commande de test de ton projet (pytest pour Python, ruby test.rb pour Ruby, etc.).
5. Charger tes préférences à l'ouverture du projet
{
"name": "load-preferences",
"type": "on-open",
"command": "source ./.env && echo 'Environnement chargé'",
"enabled": true
}
Ce hook charge automatiquement tes variables d'environnement et configurations personnelles quand tu ouvres le projet. Plus besoin de les configurer manuellement à chaque session.
Gérer les erreurs et déboguer tes hooks
Quand un hook ne fonctionne pas, Claude Code affiche un message d'erreur dans le terminal qui te guide vers la solution. Les problèmes les plus courants sont faciles à résoudre une fois que tu sais où chercher.
Erreur : "Command not found"
Ce message signifie que la commande que tu essaies d'exécuter n'est pas installée sur ton ordinateur. Par exemple, si ton hook utilise prettier mais que tu ne l'as pas installé, tu verras cette erreur.
Solution : installe l'outil manquant. Pour Prettier, tape npm install -g prettier dans ton terminal. Pour d'autres outils, consulte leur documentation d'installation officielle.
Erreur : "Permission denied"
Ton système d'exploitation bloque l'exécution de la commande pour des raisons de sécurité.
Solution : ajoute les permissions d'exécution au script. Sur macOS et Linux, utilise chmod +x nom-du-script. Sur Windows, exécute Claude Code en tant qu'administrateur (clic droit > "Exécuter en tant qu'administrateur").
Erreur : "Hook timeout"
Ton hook prend trop de temps à s'exécuter et Claude Code l'a arrêté automatiquement. La limite par défaut est de 30 secondes.
Solution : optimise ta commande pour qu'elle soit plus rapide, ou augmente le délai d'attente en ajoutant "timeout": 60 (en secondes) dans la configuration de ton hook.
Déboguer avec les logs
Active le mode verbose pour voir exactement ce que fait chaque hook :
{
"hooks": [...],
"verbose": true
}
Claude Code affichera alors chaque étape de l'exécution dans le terminal, ce qui te permet de repérer où ça coince.
Tester un hook individuellement
Plutôt que de tester ton hook en situation réelle, lance-le manuellement dans le terminal pour voir s'il fonctionne :
commande-de-ton-hook
Si la commande fonctionne seule mais pas dans le hook, le problème vient probablement du chemin d'accès ou des permissions.
Bonnes pratiques pour des hooks efficaces
Commence simple avec un ou deux hooks, puis ajoute-en progressivement une fois que tu maîtrises les bases. Un système d'automatisation trop complexe dès le début devient difficile à maintenir et à déboguer.
Garde tes hooks rapides : une commande qui prend plus de 5 secondes ralentit ton workflow au lieu de l'accélérer. Si tu as besoin d'exécuter des tâches longues, utilise-les sur des événements peu fréquents comme on-close plutôt que sur chaque modification.
Documente tes hooks dans le fichier de configuration avec des commentaires clairs. JSON ne supporte pas les commentaires natifs, mais tu peux ajouter un champ "description" dans chaque hook :
{
"name": "format-code",
"description": "Formate automatiquement le code avec Prettier après génération",
"type": "post-generate",
...
}
Versionne ton fichier .claude-hooks.json avec Git pour partager tes automatisations avec ton équipe ou les retrouver sur d'autres projets. Ajoute simplement le fichier à ton dépôt Git comme n'importe quel autre fichier de configuration.
Crée des hooks spécifiques à chaque projet plutôt que des hooks globaux. Un projet web n'a pas les mêmes besoins d'automatisation qu'un script d'analyse de données. Si tu veux quand même des hooks globaux, Claude Code te permet de créer un fichier ~/.claude-hooks.json dans ton dossier utilisateur.
Teste tes hooks sur un projet de test avant de les appliquer à ton projet principal. Crée un dossier temporaire, copie ton fichier de configuration, et vérifie que tout fonctionne comme prévu.
Si tu veux aller plus loin avec Claude Code, consulte notre guide sur les 20 commandes essentielles pour combiner les hooks avec des commandes avancées. Tu peux aussi explorer notre tutoriel complet pour débutants qui couvre tous les aspects de l'outil.
Les hooks deviennent vraiment puissants quand tu les combines avec d'autres fonctionnalités de Claude Code. Par exemple, tu peux créer un hook qui lance automatiquement une commande personnalisée que tu as définie, ou qui déclenche une séquence d'actions en chaîne.
Si tu débutes avec l'IA et l'automatisation, notre article Apprendre l'IA : par où commencer te donnera une vision d'ensemble des compétences à développer. Les hooks sont une excellente introduction au concept d'automatisation, une compétence clé en développement moderne.
Conclusion
Les hooks Claude Code transforment des tâches manuelles répétitives en automatisations qui tournent en arrière-plan. Tu viens d'apprendre à créer ton fichier de configuration, à définir des règles d'automatisation, et à résoudre les problèmes courants. Commence par un hook simple comme le formatage automatique, teste-le sur un petit projet, puis ajoute progressivement d'autres automatisations selon tes besoins. L'objectif est de gagner du temps sur les tâches techniques pour te concentrer sur l'apprentissage et la création.
