Toutes les ressources

Claude · 1 min

Les 4 Hooks Claude qui évoluent tout seul

Le package complet pour que Claude apprenne de ses propres erreurs, automatiquement.

Ce qu’il y a dedans

  • Ce que tu vas obtenir
  • Comment ça marche
  • 📁 Les 4 fichiers
  • ⚙️ Installation (3 étapes)

Le package complet pour que Claude apprenne de ses propres erreurs, automatiquement.


Ce que tu vas obtenir

4 scripts qui s'activent tout seuls à chaque session Claude Code. Ensemble, ils :

  1. Observent chaque run (outils appelés, erreurs, durée)
  2. Détectent les patterns d'échec récurrents
  3. Écrivent des règles dans .claude/rules/ que Claude lira au prochain run

Résultat : Claude se corrige tout seul entre les sessions. Plus besoin de répéter la même instruction.


Comment ça marche

code
┌─────────────┐    ┌──────────────┐    ┌─────────────┐    ┌──────────────┐
│ 01-startup  │ →  │ 02-tracker   │ →  │ 03-stop     │ →  │ 04-engine    │
│ PreToolUse  │    │ PostToolUse  │    │ Stop        │    │ Stop (gate)  │
└─────────────┘    └──────────────┘    └─────────────┘    └──────────────┘
  init session     log chaque        dump final     toutes les 4h
                   outil/erreur      OK ou FAIL     → spawn worker
                                                    → écrit règles

📁 Les 4 fichiers

Fichier 1 — 01-startup.sh

Hook : PreToolUse — Initialise l'état de la session au premier outil appelé.

code
#!/usr/bin/env bash
python3 -c "
import json, sys, os
from datetime import datetime

data = json.load(sys.stdin)
session_id = data.get('session_id', 'unknown')
sessions_dir = '.claude/observations'
session_file = f'{sessions_dir}/{session_id}.json'

os.makedirs(sessions_dir, exist_ok=True)

if not os.path.exists(session_file):
    session = {
        'session_id': session_id,
        'start_time': datetime.now().isoformat(),
        'status': 'running',
        'tools': [],
        'errors': []
    }
    with open(session_file, 'w') as f:
        json.dump(session, f, indent=2)
"

Fichier 2 — 02-tool-tracker.sh

Hook : PostToolUse — Enregistre chaque appel d'outil + détecte les erreurs.

code
#!/usr/bin/env bash
python3 -c "
import json, sys
from datetime import datetime

data = json.load(sys.stdin)
session_id = data.get('session_id', 'unknown')
tool_name = data.get('tool_name', 'unknown')
tool_response = str(data.get('tool_response', ''))

session_file = f'.claude/observations/{session_id}.json'

with open(session_file) as f:
    session = json.load(f)

is_error = any(w in tool_response.lower() for w in
    ['error', 'failed', 'exception', 'traceback', 'denied'])

session['tools'].append({
    'time': datetime.now().isoformat(),
    'tool': tool_name,
    'error': is_error
})

if is_error:
    session['errors'].append({
        'time': datetime.now().isoformat(),
        'tool': tool_name,
        'snippet': tool_response[:300]
    })

with open(session_file, 'w') as f:
    json.dump(session, f, indent=2)
"

Fichier 3 — 03-session-stop.sh

Hook : Stop — Dump l'observation complète à l'arrêt de la session.

code
#!/usr/bin/env bash
python3 -c "
import json, sys
from datetime import datetime

data = json.load(sys.stdin)
session_id = data.get('session_id', 'unknown')
session_file = f'.claude/observations/{session_id}.json'

with open(session_file) as f:
    session = json.load(f)

start = datetime.fromisoformat(session['start_time'])
duration = round((datetime.now() - start).total_seconds())

session['status'] = 'failed' if session['errors'] else 'success'
session['end_time'] = datetime.now().isoformat()
session['duration_seconds'] = duration
session['summary'] = f\"{'FAIL' if session['errors'] else 'OK'} | {len(session['tools'])} outils | {duration}s\"

with open(session_file, 'w') as f:
    json.dump(session, f, indent=2)
"

Fichier 4 — 04-rule-engine.sh

Hook : Stop — Le gate. Toutes les 4h, si 3+ nouvelles observations, spawn un worker en background qui analyse les 20 derniers runs et écrit les règles.

code
#!/usr/bin/env bash
python3 -c "
import json, sys, subprocess
from datetime import datetime, timedelta
from pathlib import Path

GATE = Path('.claude/.rule-engine-last-run')
OBS = Path('.claude/observations')
now = datetime.now()

if GATE.exists():
    last = datetime.fromisoformat(GATE.read_text().strip())
    if (now - last) < timedelta(hours=4):
        sys.exit(0)

last_dt = datetime.fromisoformat(GATE.read_text().strip()) if GATE.exists() else datetime.min
new = [f for f in OBS.glob('*.json')
       if datetime.fromtimestamp(f.stat().st_mtime) > last_dt
       and json.loads(f.read_text()).get('status') in ('success', 'failed')]

if len(new) < 3:
    sys.exit(0)

GATE.parent.mkdir(exist_ok=True)
GATE.write_text(now.isoformat())

subprocess.Popen(
    ['python3', '.claude/hooks/worker-rules.py'],
    stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
    start_new_session=True
)
"

Bonus — worker-rules.py

Le worker lancé en background par le fichier 4. Analyse les 20 derniers runs, détecte les outils qui plantent en boucle, écrit les règles.

code
#!/usr/bin/env python3
import json
from pathlib import Path
from datetime import datetime
from collections import Counter

OBS_DIR = Path('.claude/observations')
RULES_DIR = Path('.claude/rules')
RULES_DIR.mkdir(exist_ok=True)

obs_files = sorted(
    [f for f in OBS_DIR.glob('*.json')
     if json.loads(f.read_text()).get('status') in ('success', 'failed')],
    key=lambda f: f.stat().st_mtime
)[-20:]

sessions = [json.loads(f.read_text()) for f in obs_files]
failed = [s for s in sessions if s['status'] == 'failed']

if not failed:
    exit(0)

error_tools = Counter()
for s in failed:
    for err in s.get('errors', []):
        error_tools[err.get('tool', 'unknown')] += 1

rules = [
    f"- L'outil `{tool}` a échoué {count} fois. Vérifier permissions et contexte avant d'appeler."
    for tool, count in error_tools.most_common(5) if count >= 2
]

if not rules:
    exit(0)

ts = datetime.now().strftime('%Y%m%d_%H%M%S')
rule_file = RULES_DIR / f'auto-{ts}.md'
rule_file.write_text(
    f"# Règles auto — {datetime.now().strftime('%Y-%m-%d %H:%M')}\n\n"
    f"Basées sur {len(failed)} sessions en échec / {len(sessions)} analysées.\n\n"
    + '\n'.join(rules) + '\n'
)

⚙️ Installation (3 étapes)

  1. Crée le dossier .claude/hooks/ dans ton projet et colle les 5 fichiers dedans.
  2. Ajoute ce bloc dans ton .claude/settings.json :
code
{
  "hooks": {
    "PreToolUse": [{"matcher": ".*", "hooks": [
      {"type": "command", "command": "bash .claude/hooks/01-startup.sh"}
    ]}],
    "PostToolUse": [{"matcher": ".*", "hooks": [
      {"type": "command", "command": "bash .claude/hooks/02-tool-tracker.sh"}
    ]}],
    "Stop": [{"hooks": [
      {"type": "command", "command": "bash .claude/hooks/03-session-stop.sh"},
      {"type": "command", "command": "bash .claude/hooks/04-rule-engine.sh"}
    ]}]
  }
}
  1. Rends les scripts exécutables : chmod +x .claude/hooks/*.sh

C'est tout. Le loop démarre au prochain run.


Rejoins CORE LABS®

S’inscrire à la newsletter

Pas le temps de tout monter toi-même ?

Je structure ta boîte : systèmes, process et un OS qui fait tourner l’opérationnel sans que tout repasse par toi. On commence par un diagnostic de 45 minutes : on regarde comment ta boîte tourne, ce qui te coûte le plus, et tu repars avec un récap écrit.

ou écris-moi :@capitain.aimaxence@corelabs.studio