Comment j’ai donné une mémoire à Claude Code avec un système de post-mortem automatique

ParPhil MAJ

TL;DR — Claude Code oublie tout entre chaque session. J’ai construit un système de logging + analyse qui capture automatiquement mes prompts, détecte les patterns récurrents, et génère des recommandations concrètes pour améliorer mon workflow. Voici comment le reproduire.

Le constat : sans données, pas d’amélioration

Après plusieurs semaines intensives sur un projet avec Claude Code, un pattern frustrant s’est imposé :

  • Je posais les mêmes questions sur l’authentification Supabase
  • Les mêmes types de bugs revenaient régulièrement
  • Mon fichier CLAUDE.md restait statique alors que mes besoins évoluaient

Le problème fondamental ? Aucune visibilité sur mes interactions. Impossible de savoir ce que je demandais le plus souvent, quelles erreurs se répétaient, ou ce qui manquait à ma documentation.

La solution : tout logger automatiquement, puis analyser.

TL;DR Donne-moi juste le script

Pas le temps de lire ? Je comprends. Lance ça :

curl -sO https://raw.githubusercontent.com/inforeole/claude-code-toolkit/post-mortem/install.sh && bash install.sh

Boom. Système de post-mortem installé. Lance npm run postmortem quand tu es prêt à affronter la réalité.

Tu veux comprendre ce que tu viens d’installer ? Continue à lire.

L’architecture : Hooks + JSONL + Script d’analyse

Claude Code supporte les hooks — des scripts exécutés sur certains événements. J’utilise le hook UserPromptSubmit pour capturer chaque prompt envoyé.

Structure du projet :

.claude/
├── settings.json          # Configuration des hooks
├── scripts/
│   ├── log-prompt.sh      # Capture chaque prompt
│   └── analyze.js         # Génère le rapport
└── logs/
    └── prompts.jsonl      # Historique (gitignore)

Étape 1 : Configurer le hook

Dans .claude/settings.json :

{
  "hooks": {
    "UserPromptSubmit": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/scripts/log-prompt.sh",
            "timeout": 5000
          }
        ]
      }
    ]
  }
}

Chaque message envoyé déclenche le script de logging.

Étape 2 : Le script de logging

.claude/scripts/log-prompt.sh :

#!/bin/bash
# Log user prompts to JSONL file for post-mortem analysis
# macOS compatible

LOG_DIR="$(dirname "$0")/../logs"
LOG_FILE="$LOG_DIR/prompts.jsonl"

mkdir -p "$LOG_DIR"

# Claude Code passe les données via stdin en JSON
INPUT=$(cat)

[ -z "$INPUT" ] && exit 0

# Extraction du prompt depuis le JSON
PROMPT=$(echo "$INPUT" | python3 -c 'import sys,json; data=json.load(sys.stdin); print(data.get("prompt",""))' 2>/dev/null)
[ -z "$PROMPT" ] && PROMPT="$INPUT"

# Métadonnées
TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
GIT_BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "unknown")
GIT_HASH=$(git rev-parse --short HEAD 2>/dev/null || echo "unknown")

# Échappement JSON
ESCAPED_PROMPT=$(printf '%s' "$PROMPT" | python3 -c 'import sys,json; print(json.dumps(sys.stdin.read())[1:-1])')

# Append JSONL
echo "{\"timestamp\":\"$TIMESTAMP\",\"branch\":\"$GIT_BRANCH\",\"commit\":\"$GIT_HASH\",\"prompt\":\"$ESCAPED_PROMPT\"}" >> "$LOG_FILE"

Points clés :

  • Format JSONL (une ligne JSON par entrée) pour faciliter l’analyse
  • Contexte git automatique pour la traçabilité
  • Compatible macOS natif

Étape 3 : Le script d’analyse

.claude/scripts/analyze.js — voici les fonctions essentielles :

#!/usr/bin/env node
import { readFileSync, writeFileSync, existsSync } from 'fs';
import { execSync } from 'child_process';
import { fileURLToPath } from 'url';
import { dirname, join } from 'path';

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
const LOGS_DIR = join(__dirname, '..', 'logs');
const REPORT_FILE = join(__dirname, '..', 'report.md');

// Parse JSONL
function parseJsonl(filepath) {
  if (!existsSync(filepath)) return [];
  return readFileSync(filepath, 'utf-8')
    .split('\n')
    .filter(line => line.trim())
    .map(line => { try { return JSON.parse(line); } catch { return null; } })
    .filter(Boolean);
}

// Catégorisation automatique des prompts
function categorizePrompts(prompts) {
  const categories = { bugs: [], features: [], questions: [], refactoring: [], other: [] };
  
  for (const p of prompts) {
    const text = (p.prompt || '').toLowerCase();
    if (/\b(bug|fix|error|crash|broken)\b/.test(text)) categories.bugs.push(p);
    else if (/\b(add|create|implement|ajoute|crée)\b/.test(text)) categories.features.push(p);
    else if (/\?|comment|pourquoi|what|how|why/.test(text)) categories.questions.push(p);
    else if (/\b(refactor|clean|simplif|améliore)\b/.test(text)) categories.refactoring.push(p);
    else categories.other.push(p);
  }
  return categories;
}

// Détection des mots-clés récurrents
function findRepeatedPatterns(prompts) {
  const patterns = {};
  for (const p of prompts) {
    const words = (p.prompt || '').toLowerCase()
      .replace(/[^a-zàâäéèêëïîôùûü\s]/g, '')
      .split(/\s+/)
      .filter(w => w.length > 4);
    for (const word of words) patterns[word] = (patterns[word] || 0) + 1;
  }
  return Object.entries(patterns)
    .filter(([, count]) => count > 2)
    .sort((a, b) => b[1] - a[1])
    .slice(0, 20);
}

Le script complet génère un rapport Markdown avec :

  • Répartition des prompts par catégorie
  • Mots-clés les plus fréquents
  • Analyse du ratio fix/feature depuis l’historique git
  • Recommandations concrètes pour CLAUDE.md

Étape 4 : Intégration npm

Dans package.json :

{
  "scripts": {
    "postmortem": "node .claude/scripts/analyze.js"
  }
}

Étape 5 : Gitignore

Les logs restent locaux :

.claude/logs/
.claude/report.md
.claude/settings.local.json

Exemple de rapport généré

📊 Données chargées:
   - 47 prompts
   - 3 erreurs  
   - 51 commits

# Rapport Post-Mortem

| Métrique          | Valeur |
|-------------------|--------|
| Prompts analysés  | 47     |
| Erreurs détectées | 3      |
| Commits (30j)     | 51     |
| Ratio fix/feature | 10/24  |

## Répartition des Prompts
- 🐛 Bugs/Fixes: 12
- ✨ Features: 18
- ❓ Questions: 8
- 🔧 Refactoring: 4

## Mots-clés Fréquents
- **supabase**: 7 fois
- **authentication**: 5 fois
- **error**: 4 fois

## Recommandations pour CLAUDE.md
1. Documenter "supabase" (mentionné 7 fois)
2. Documenter "authentication" (mentionné 5 fois)

Ce que ça révèle concrètement

Ratio fix/feature déséquilibré → Signal de dette technique à traiter.

Mots-clés récurrents → Sujets à documenter dans CLAUDE.md. Si je pose 7 fois des questions sur Supabase, c’est que ma documentation est insuffisante sur ce point.

Patterns d’erreurs → Identification des outils ou workflows problématiques.

Pistes d’évolution

  • Analyse IA : Envoyer les logs à Claude via API pour une analyse sémantique plus fine
  • Dashboard temps réel : Interface web avec visualisation des tendances
  • Alertes automatiques : Notification Slack si le ratio fix/feature dépasse un seuil
  • Benchmarking : Comparaison des métriques entre projets

Conclusion

Ce système transforme Claude Code d’un outil « amnésique » en un assistant qui permet une amélioration continue. En 30 minutes de setup, vous obtenez une visibilité complète sur vos interactions et des recommandations actionnables.

Le vrai gain n’est pas le rapport lui-même — c’est le feedback loop qu’il crée entre vos sessions de travail et votre documentation.

Publications similaires