Claude Code Hooks : Automatiser et Sécuriser Votre Workflow de Développement (Guide 2026)

Les Hooks Claude Code : du contrôle déterministe sur votre agent IA

Les hooks sont l'une des fonctionnalités les plus puissantes — et les plus sous-estimées — de Claude Code. Contrairement aux instructions dans CLAUDE.md que l'IA peut interpréter librement, les hooks sont des commandes shell déterministes qui s'exécutent automatiquement à des points précis du cycle de vie de Claude Code.

Résultat : des règles que Claude ne peut pas ignorer, quelle que soit la formulation de votre prompt.

Sommaire

Qu'est-ce qu'un hook ?

Les Claude Code hooks permettent d'automatiser n'importe quelle action dans votre workflow de développement. Si vous débutez avec Claude Code, consultez d'abord notre [guide pour débutants](/blog/claude-code-pour-debutants). Pour les commandes personnalisées, voir aussi les [Skills Claude Code](/blog/claude-code-skills-creer-commandes-personnalisees).

Un hook Claude Code est une commande shell qui se déclenche automatiquement à un moment précis de l'exécution de Claude Code. Pensez aux hooks Git (pre-commit, post-merge), mais pour votre agent IA.

Pourquoi les hooks sont essentiels

La différence fondamentale : CLAUDE.md est une suggestion, un hook est une obligation.

Les 5 types de hooks

Claude Code propose 5 événements de cycle de vie auxquels vous pouvez attacher des hooks :

1. PreToolUse — Avant chaque action

Se déclenche avant que Claude exécute un outil (écriture de fichier, commande bash, etc.). Idéal pour :

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "command": "python3 ~/.claude/hooks/block-dangerous.py"
      }
    ]
  }
}

2. PostToolUse — Après chaque action

Se déclenche après l'exécution d'un outil. Parfait pour :

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "command": "npx prettier --write $CLAUDE_FILE_PATH"
      }
    ]
  }
}

3. Notification — À chaque notification

Se déclenche quand Claude Code envoie une notification (fin de tâche, erreur, etc.) :

{
  "hooks": {
    "Notification": [
      {
        "command": "afplay /System/Library/Sounds/Glass.aiff"
      }
    ]
  }
}

4. Stop — Quand Claude termine

Se déclenche quand Claude Code finit de répondre :

{
  "hooks": {
    "Stop": [
      {
        "command": "bash ~/.claude/hooks/post-task-report.sh"
      }
    ]
  }
}

5. SessionStart — Au démarrage

Se déclenche au lancement d'une session Claude Code :

{
  "hooks": {
    "SessionStart": [
      {
        "command": "echo 'Session démarrée à $(date)' >> ~/.claude/session.log"
      }
    ]
  }
}

Configuration pas à pas

Où configurer les hooks

Les hooks se configurent dans vos fichiers de settings Claude Code :

Méthode 1 : La commande /hooks

Depuis début 2026, Claude Code propose une commande interactive pour configurer les hooks sans éditer manuellement le JSON :

# Dans une session Claude Code
/hooks

Un menu interactif vous guide pour :

Méthode 2 : Édition manuelle

Pour un contrôle total, éditez directement le fichier de settings :

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "command": "python3 ~/.claude/hooks/validate-command.py",
        "timeout": 5000
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "command": "npx prettier --write $CLAUDE_FILE_PATH",
        "timeout": 10000
      }
    ],
    "Notification": [
      {
        "command": "terminal-notifier -message '$CLAUDE_NOTIFICATION' -title 'Claude Code'"
      }
    ]
  }
}

Variables d'environnement disponibles

Les hooks reçoivent des informations via des variables d'environnement :

5 hooks indispensables pour votre workflow

Hook 1 : Bloquer les commandes dangereuses

Le hook le plus important pour la sécurité. Ce script Python intercepte les commandes bash avant exécution :

#!/usr/bin/env python3
# ~/.claude/hooks/block-dangerous.py
import sys, json, os

# Lire l'input du hook
input_data = json.loads(sys.stdin.read())
command = input_data.get("tool_input", {}).get("command", "")

# Commandes interdites
BLOCKED = [
    "rm -rf /", "rm -rf ~", "rm -rf .",
    "git push --force", "git reset --hard",
    "DROP TABLE", "DROP DATABASE",
    "> /dev/sda", "mkfs", "dd if="
]

for blocked in BLOCKED:
    if blocked.lower() in command.lower():
        # Retourner un code d'erreur bloque l'exécution
        print(f"BLOQUÉ : commande dangereuse détectée ({blocked})")
        sys.exit(1)

sys.exit(0)

Ce hook est votre filet de sécurité — même en [Auto Mode](/blog/claude-code-auto-mode-permissions-intelligentes), il ajoute une couche de protection supplémentaire.

Hook 2 : Auto-formatage du code

Plus besoin de demander à Claude de formater — le code est formaté automatiquement après chaque édition :

#!/bin/bash
# ~/.claude/hooks/auto-format.sh
FILE="$CLAUDE_FILE_PATH"

case "$FILE" in
  *.ts|*.tsx|*.js|*.jsx)
    npx prettier --write "$FILE" 2>/dev/null
    ;;
  *.py)
    black "$FILE" 2>/dev/null
    ;;
  *.go)
    gofmt -w "$FILE" 2>/dev/null
    ;;
  *.rs)
    rustfmt "$FILE" 2>/dev/null
    ;;
esac

Hook 3 : Notification Slack en fin de tâche

Recevez un message Slack quand Claude termine un travail long :

#!/bin/bash
# ~/.claude/hooks/notify-slack.sh
WEBHOOK_URL="https://hooks.slack.com/services/YOUR/WEBHOOK/URL"

curl -s -X POST "$WEBHOOK_URL" \
  -H 'Content-type: application/json' \
  -d "{
    \"text\": \"Claude Code a terminé une tâche\",
    \"blocks\": [{
      \"type\": \"section\",
      \"text\": {
        \"type\": \"mrkdwn\",
        \"text\": \"*Claude Code* a terminé son travail sur le projet.\"
      }
    }]
  }"

Hook 4 : Lint automatique pré-commit

Assurez-vous que le code passe le linter avant tout commit :

#!/usr/bin/env python3
# ~/.claude/hooks/pre-commit-lint.py
import sys, json, subprocess

input_data = json.loads(sys.stdin.read())
command = input_data.get("tool_input", {}).get("command", "")

if "git commit" in command:
    result = subprocess.run(
        ["npx", "eslint", ".", "--ext", ".ts,.tsx"],
        capture_output=True, text=True
    )
    if result.returncode != 0:
        print("BLOQUÉ : des erreurs ESLint doivent être corrigées")
        print(result.stdout[:500])
        sys.exit(1)

sys.exit(0)

Hook 5 : Journal d'activité

Gardez une trace de tout ce que Claude Code fait dans votre projet :

#!/bin/bash
# ~/.claude/hooks/activity-log.sh
LOG_FILE="$HOME/.claude/activity.log"
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
echo "[$TIMESTAMP] Tool: $CLAUDE_TOOL_NAME | File: $CLAUDE_FILE_PATH" >> "$LOG_FILE"

Ce journal est précieux pour l'audit et le debugging, surtout quand vous utilisez Claude Code en [mode headless dans vos pipelines CI/CD](/blog/claude-code-devops-cicd-pipeline-2026).

Hooks et sécurité

Les hooks sont votre première ligne de défense contre les risques liés aux agents IA autonomes. Voici pourquoi ils sont indispensables :

Protection contre le prompt injection

Le prompt injection est une menace réelle : du code malveillant caché dans un fichier source peut tenter de manipuler Claude Code. Les hooks PreToolUse permettent de détecter et bloquer ces tentatives avant qu'elles n'aient d'effet.

Pour approfondir ce sujet, consultez notre article sur la [sécurité des assistants IA code](/blog/securite-assistants-ia-code-2026).

Conformité et audit

En entreprise, les hooks permettent de garantir la conformité :

Hooks et Agent Teams

Quand vous utilisez les [Agent Teams](/blog/claude-code-agent-teams) pour le travail parallèle, les hooks s'appliquent à chaque sous-agent. C'est crucial : sans hooks, un sous-agent pourrait exécuter des actions non souhaitées sans supervision directe.

Hooks vs CLAUDE.md : quand utiliser quoi

Règle simple : utilisez CLAUDE.md pour tout ce qui est une préférence et les hooks pour tout ce qui est une obligation.

Exemple combiné

# CLAUDE.md
- Utilise TypeScript strict
- Privilégie les composants fonctionnels React
- Écris les commentaires en français

// settings.json — hooks
{
  "hooks": {
    "PostToolUse": [{
      "matcher": "Edit|Write",
      "command": "npx prettier --write $CLAUDE_FILE_PATH"
    }],
    "PreToolUse": [{
      "matcher": "Bash",
      "command": "python3 ~/.claude/hooks/block-dangerous.py"
    }]
  }
}

CLAUDE.md guide le style, les hooks garantissent la qualité et la sécurité.

Bonnes pratiques

1. Commencez simple

Ne créez pas 20 hooks d'un coup. Commencez par les deux essentiels :

Ajoutez progressivement selon vos besoins.

2. Gérez les timeouts

Chaque hook a un timeout par défaut. Si votre hook exécute un linter sur un gros projet, augmentez le timeout :

{
  "command": "npx eslint .",
  "timeout": 30000
}

3. Testez vos hooks indépendamment

Avant de les brancher à Claude Code, testez vos scripts en standalone :

echo '{"tool_input":{"command":"rm -rf /"}}' | python3 ~/.claude/hooks/block-dangerous.py
# Devrait retourner un code d'erreur

4. Versionnez les hooks d'équipe

Mettez les hooks partagés dans .claude/settings.json et les scripts dans un dossier .claude/hooks/ versionné. Chaque développeur de l'équipe bénéficiera automatiquement des mêmes protections.

5. Combinez avec les Skills

Les [Skills Claude Code](/blog/claude-code-skills-creer-commandes-personnalisees) complètent parfaitement les hooks : les skills définissent quoi faire, les hooks comment le sécuriser.

Conclusion

Les hooks Claude Code transforment votre agent IA d'un assistant conversationnel en un outil de développement professionnel avec des garanties déterministes. En combinant hooks de sécurité, auto-formatage et notifications, vous construisez un workflow où la productivité ne se fait plus au détriment de la qualité.

La clé : commencez par les hooks de sécurité, puis ajoutez progressivement l'automatisation. En quelques heures de configuration, vous économiserez des dizaines d'heures de travail répétitif.

Pour maîtriser les hooks et toutes les fonctionnalités avancées de Claude Code, notre [formation complète](https://go.saas-ia.io/se-faire-remplacer-par-lia) couvre ces sujets avec des exercices pratiques guidés.

---

*Sources : Anthropic Claude Code Documentation, Claude Code Hooks Guide 2026, mars 2026.*