Claude Code ne se limite pas a un assistant qui repond a vos questions. Sous le capot, il embarque un systeme d'extensibilite puissant qui permet de transformer chaque action en declencheur automatique et de distribuer le travail entre plusieurs agents specialises. Les hooks et les subagents representent deux mecanismes complementaires qui, combines, permettent de construire des pipelines de developpement entierement automatises. Si vous utilisez deja Claude Code au quotidien, ces fonctionnalites vont changer votre facon de travailler.
Pour les fondamentaux de Claude Code, consultez le [guide complet Claude Code 2026](/claude-code-guide-complet-2026/) avant de plonger dans ces fonctionnalites avancees.
Les hooks Claude Code : intercepter et reagir
Les hooks sont des scripts ou commandes qui s'executent automatiquement en reponse a des evenements specifiques dans le cycle de vie de Claude Code. Ils fonctionnent comme des middleware : ils interceptent le flux d'execution, executent une logique personnalisee, et peuvent meme bloquer une action si les conditions ne sont pas remplies.
Claude Code propose trois types de hooks principaux :
- pre-tool-use : s'execute avant qu'un outil ne soit appele (edition de fichier, commande bash, etc.)
- post-tool-use : s'execute apres l'execution d'un outil, avec acces au resultat
- notification : se declenche lors d'evenements systeme (fin de tache, erreur, attente d'input)
Chaque hook recoit un objet JSON en stdin contenant le contexte de l'evenement : nom de l'outil, parametres, resultat (pour post-tool-use), et metadata de la session.
Configuration des hooks dans settings.json
Les hooks se configurent dans le fichier .claude/settings.json a la racine de votre projet, ou dans le fichier global ~/.claude/settings.json. La structure suit un format declaratif qui associe un type d'evenement a une commande shell.
{
"hooks": {
"pre-tool-use": [
{
"matcher": "Edit|Write",
"command": "/bin/bash .claude/hooks/pre-edit.sh"
}
],
"post-tool-use": [
{
"matcher": "Bash",
"command": "/bin/bash .claude/hooks/post-bash.sh"
}
],
"notification": [
{
"command": "/bin/bash .claude/hooks/notify.sh"
}
]
}
}
Le champ matcher filtre les outils concernes via une expression reguliere. Sans matcher, le hook s'execute pour tous les outils du type donne. La commande recoit le contexte JSON sur stdin et peut retourner un JSON sur stdout pour modifier le comportement de Claude Code.
Un hook pre-tool-use peut bloquer l'execution en retournant un statut d'erreur (exit code non-zero). C'est le mecanisme ideal pour implementer des garde-fous automatiques.
Exemples concrets de hooks
Auto-lint apres chaque edition de fichier
L'un des cas d'usage les plus immediats : lancer automatiquement un linter apres chaque modification de fichier pour garantir la qualite du code en continu.
#!/bin/bash
# .claude/hooks/post-edit-lint.sh
# Hook post-tool-use pour lancer ESLint apres chaque edit
input=$(cat -)
tool_name=$(echo "$input" | jq -r '.tool_name')
file_path=$(echo "$input" | jq -r '.tool_input.file_path // empty')
if [ "$tool_name" = "Edit" ] || [ "$tool_name" = "Write" ]; then
if [ -n "$file_path" ]; then
extension="${file_path##*.}"
if [ "$extension" = "js" ] || [ "$extension" = "ts" ] || [ "$extension" = "tsx" ]; then
npx eslint --fix "$file_path" 2>/dev/null
if [ $? -ne 0 ]; then
echo '{"message": "ESLint a detecte des erreurs non corrigibles automatiquement"}'
fi
fi
fi
fi
La configuration correspondante dans settings.json :
{
"hooks": {
"post-tool-use": [
{
"matcher": "Edit|Write",
"command": "/bin/bash .claude/hooks/post-edit-lint.sh"
}
]
}
}
Notification Slack sur commit
Ce hook envoie une notification Slack chaque fois que Claude Code execute un commit Git, avec le message de commit et le nom de la branche.
#!/bin/bash
# .claude/hooks/notify-slack-commit.sh
# Hook post-tool-use pour notifier Slack apres un commit
input=$(cat -)
tool_name=$(echo "$input" | jq -r '.tool_name')
command=$(echo "$input" | jq -r '.tool_input.command // empty')
if [ "$tool_name" = "Bash" ] && echo "$command" | grep -q "git commit"; then
branch=$(git branch --show-current)
last_commit=$(git log -1 --pretty=format:"%s")
curl -s -X POST "$SLACK_WEBHOOK_URL" \
-H "Content-Type: application/json" \
-d "{
\"text\": \"Claude Code a commite sur *${branch}* : ${last_commit}\"
}" > /dev/null
fi
Validation securite avant push
Un hook pre-tool-use qui bloque tout push vers la branche main sans validation explicite. Ce type de garde-fou evite les erreurs couteuses en production.
#!/bin/bash
# .claude/hooks/pre-push-guard.sh
# Bloque les push directs vers main/master
input=$(cat -)
tool_name=$(echo "$input" | jq -r '.tool_name')
command=$(echo "$input" | jq -r '.tool_input.command // empty')
if [ "$tool_name" = "Bash" ] && echo "$command" | grep -q "git push"; then
branch=$(git branch --show-current)
if [ "$branch" = "main" ] || [ "$branch" = "master" ]; then
if ! echo "$command" | grep -q "\-\-force-with-lease"; then
echo '{"error": "Push direct vers main/master bloque. Utilisez une branche feature et une PR."}' >&2
exit 1
fi
fi
fi
Pour approfondir la configuration des fichiers de regles qui completent ces hooks, consultez le [guide sur les fichiers CLAUDE.md](/claude-code-claude-md-rules-fichier/).
Les subagents : distribuer le travail avec Task
Les subagents representent la deuxieme couche d'automatisation de Claude Code. Via l'outil interne Task, Claude Code peut lancer des agents specialises qui travaillent en parallele sur des taches isolees. Chaque subagent dispose de son propre contexte, de ses propres outils, et retourne un resultat structure a l'agent principal.
Le mecanisme fonctionne comme un systeme de delegation : l'agent principal decompose un probleme complexe en sous-taches, attribue chacune a un subagent specialise, puis synthetise les resultats. Les subagents s'executent dans des contextes isoles, ce qui garantit qu'ils ne se marchent pas dessus.
Recherche codebase en parallele
Quand Claude Code doit comprendre une architecture complexe, il peut lancer plusieurs subagents simultanement pour explorer differentes parties du code :
- Un subagent analyse la structure des modeles de donnees
- Un autre parcourt les routes API et leurs handlers
- Un troisieme examine les tests existants et la couverture
Chaque agent retourne une synthese structuree. L'agent principal fusionne ces analyses pour produire une comprehension globale en une fraction du temps qu'il aurait fallu pour tout parcourir sequentiellement.
Tests en parallele
Les subagents sont particulierement efficaces pour les taches de validation. Plutot que d'executer une suite de tests de maniere sequentielle, Claude Code peut distribuer le travail :
Agent principal → Demande : "Verifie que le refactoring n'a rien casse"
├── Subagent 1 : Execute les tests unitaires du module auth
├── Subagent 2 : Execute les tests d'integration API
├── Subagent 3 : Verifie le typage TypeScript sur les fichiers modifies
└── Subagent 4 : Recherche les imports casses dans le projet
L'agent principal collecte les resultats et produit un rapport consolide. Cette approche reduit significativement le temps de feedback sur les changements importants.
Generation de documentation
Un autre cas d'usage courant : generer de la documentation technique pour plusieurs modules simultanement. Chaque subagent prend en charge un module, analyse ses exports, ses types, et ses patterns d'utilisation, puis produit une documentation formatee. L'agent principal assemble le tout en un document coherent avec une table des matieres et des liens croises.
Combiner hooks et subagents pour des workflows avances
La veritable puissance emerge quand on combine hooks et subagents dans un workflow integre. Voici un exemple de pipeline automatise pour un workflow de code review :
{
"hooks": {
"post-tool-use": [
{
"matcher": "Bash",
"command": "/bin/bash .claude/hooks/post-commit-review.sh"
}
]
}
}
Le hook detecte un commit et declenche une analyse multi-agents :
1. Le hook post-tool-use intercepte le commit
2. Il notifie Claude Code qu'une review est necessaire
3. Claude Code lance des subagents en parallele : un pour la securite (detection de secrets, dependances vulnerables), un pour le style (conventions du projet, patterns), un pour la logique metier (coherence avec l'architecture existante)
4. Les resultats sont agreges et presentes sous forme de rapport
Ce type de workflow transforme Claude Code en un systeme de CI/CD local qui reagit en temps reel a chaque modification, sans attendre un pipeline distant.
Bonnes pratiques : hooks vs subagents
Quand utiliser les hooks
Les hooks conviennent aux actions reactives et legeres :
- Validation de format ou de securite avant une action
- Notifications externes (Slack, email, webhooks)
- Transformations automatiques (formatage, lint, tri des imports)
- Journalisation et audit des actions Claude Code
- Garde-fous pour empecher des operations dangereuses
Un hook doit rester rapide. S'il prend plus de quelques secondes, il ralentit l'ensemble du flux de travail de Claude Code. Gardez la logique simple et deleguer les traitements lourds a des processus asynchrones.
Quand utiliser les subagents
Les subagents conviennent aux taches proactives et complexes :
- Analyses necessitant la lecture de nombreux fichiers
- Taches parallelisables (tests, recherche, generation)
- Operations qui beneficient d'un contexte isole
- Decomposition de problemes complexes en sous-problemes
Les subagents consomment des tokens supplementaires puisque chacun dispose de son propre contexte. Utilisez-les quand le gain de temps ou de qualite justifie le cout.
Limites a connaitre
Quelques contraintes a garder en tete lors de l'utilisation de ces mecanismes :
- Hooks : les scripts doivent etre idempotents (executables plusieurs fois sans effet de bord). Un hook qui echoue silencieusement est preferable a un hook qui bloque tout le workflow. Testez-les isolement avant de les activer.
- Subagents : ils n'ont pas acces au contexte conversationnel complet de l'agent parent. Les instructions doivent etre explicites et auto-suffisantes. Le nombre de subagents paralleles est limite par les quotas API.
- Combinaison : evitez les boucles infinies ou un hook declenche une action qui declenche un autre hook. Utilisez des conditions de filtrage strictes dans vos matchers.
Vers un environnement de developpement autonome
Les hooks et subagents transforment Claude Code d'un simple assistant conversationnel en une plateforme d'automatisation programmable. Chaque equipe peut construire ses propres conventions, ses garde-fous, et ses pipelines adaptes a son contexte.
L'approche recommandee est progressive : commencez par un hook simple (lint automatique ou notification), validez que le mecanisme fonctionne dans votre environnement, puis ajoutez des couches d'automatisation au fur et a mesure. Les subagents viendront naturellement quand vous identifierez des taches repetitives qui beneficient de la parallelisation.
Pour mettre en place ces automatisations dans votre projet, le [guide complet Claude Code 2026](/claude-code-guide-complet-2026/) couvre l'installation et la configuration initiale qui servent de fondation a tout ce qui est decrit ici.
