Claude Code /dream : Nettoyer sa Mémoire IA

Publié le 25 mars 2026

La commande /dream de Claude Code est une fonction cachée qui nettoie et consolide automatiquement la mémoire de tes projets. Le problème : après 20+ sessions, le fichier memory.md (limité à 200 lignes) se remplit de dates relatives inutiles, de contradictions entre fichiers et de notes obsolètes sur du code supprimé. Claude Code devient littéralement plus stupide à chaque session. La solution /dream fonctionne en 4 phases : Orient (lecture de l'index), Signal (analyse des transcripts JSONL), Consolidate (fusion des doublons, conversion en dates absolues, suppression des contradictions) et Prune (maintien de l'index sous 200 lignes avec réorganisation par pertinence). Résultat concret : un memory.md de 280 lignes tombe à 142, les frameworks obsolètes sont remplacés par les actuels, et les doublons sont fusionnés. Tu peux même automatiser le processus avec un hook qui se déclenche toutes les 24h après 5 sessions accumulées.

Pourquoi la mémoire de Claude Code devient un problème critique ?

100% des utilisateurs de Claude Code partagent le même problème : la mémoire. Plus tu accumules de sessions, plus Claude Code devient stupide. C'est contre-intuitif, mais c'est la réalité. La mémoire, censée aider Claude Code à prendre de meilleures décisions, finit par le confondre quand elle n'est pas entretenue.

Au-delà de 20 sessions sur un projet, Claude Code commence à oublier des éléments importants. Quand tu as des centaines de projets déployés avec potentiellement des milliers de sessions, c'est un bazar total. C'est exactement pour ça qu'une commande cachée appelée /dream existe : elle consolide, nettoie et réorganise ta mémoire pour que Claude Code redevienne performant.

L'architecture mémoire de Claude Code

Chaque projet Claude Code possède son dossier mémoire dédié. Si tu ne connais pas encore la structure de base, jette un œil au guide complet de Claude Code. Concrètement, tout se trouve dans le dossier racine .claude/project/. Dans ce dossier, tu trouves un sous-dossier memory/ qui contient :

• memory.md : le fichier principal, limité à 200 lignes, chargé à chaque session
• Des fichiers de debugging, préférences, patterns architecturaux
• Des fichiers .jsonl de transcripts de conversations
• Des notes diverses accumulées au fil du temps

La limite critique, c'est ces 200 lignes du memory.md. Au-delà, Claude Code sature. Et le problème, c'est que sans maintenance, ce fichier dépasse facilement cette limite avec du contenu obsolète.

Ce que Claude Code note dans ton dos

Il y a un mécanisme qu'on appelle l'automémory. Sans te demander ton autorisation, Claude Code sauvegarde en silence à chaque session :

• Les commandes de build que tu utilises
• Les patterns de debug récurrents
• Tes préférences de code
• Les décisions d'architecture que tu prends

C'est bien en théorie. En pratique, après des dizaines de sessions, tu te retrouves avec des fichiers txt, des fichiers jsonl empilés, des notes contradictoires. C'est un bordel sans nom. Et ce bordel, il pollue directement la qualité des réponses de Claude Code sur ton projet.

Quels sont les 3 types de pollution mémoire à éliminer ?

Avant de parler de la solution, il faut comprendre exactement ce qui pourrit ta mémoire. Il y a 3 types de pollution principales qui dégradent les performances de Claude Code. Si tu appliques déjà les bonnes pratiques Claude Code, tu as peut-être limité les dégâts, mais personne n'y échappe totalement.

Les dates relatives qui ne veulent rien dire

Premier type de pollution : les dates relatives. Quand Claude Code écrit "hier, nous avons migré la base de données" dans un fichier mémoire, ça a du sens le lendemain. Mais dans 3 semaines ? "Hier" ne veut plus rien dire. Pire : si tu as 6 fichiers différents qui mentionnent "hier" à des dates différentes, c'est la confusion totale.

Imagine 50 entrées mémoire qui disent "aujourd'hui on a fait ça". Aujourd'hui quand ? Sans date absolue (25 mars 2026, par exemple), ces informations sont inutiles voire nuisibles. Claude Code ne peut pas reconstruire une chronologie fiable.

Les contradictions entre fichiers

Deuxième type : les contradictions. Tu as un fichier qui dit que ton API utilise Express. Un autre, plus récent, mentionne que tu es passé à Fastify. Les deux coexistent dans la mémoire. Claude Code ne sait plus lequel est valide. Résultat : il peut te proposer du code Express alors que tu as migré depuis des semaines. C'est exactement le genre de bug silencieux qui te fait perdre des heures.

Les notes obsolètes sur du code supprimé

Troisième type : les notes obsolètes. Tu as debuggé une fonction il y a un mois. Tu as finalement supprimé cette fonction. Mais Claude Code a gardé en mémoire toutes les notes de debug associées. Des librairies que tu as testées puis abandonnées restent référencées. Ce bruit de fond encombre les 200 lignes précieuses de ton memory.md avec des informations qui ne servent plus à rien.

Comment fonctionne la commande /dream en 4 phases ?

La commande /dream est une fonction de consolidation réflective de la mémoire. En termes simples : Claude Code va relire toute sa mémoire, identifier ce qui est utile, fusionner les doublons, corriger les incohérences et nettoyer le superflu. Le tout en 4 phases distinctes et automatisées.

Un repo GitHub de Pybald AI appelé "Cloud Code System Prompt" documente le prompt système derrière cette commande. La description officielle : "Tu effectues un dream, une passe réflective sur tes fichiers mémoire pour consolider les apprentissages récents en souvenirs durables et organisés."

Phase 1 : Orient (lecture de l'index)

La première phase, c'est Orient. Claude Code lit l'intégralité de l'index mémoire, c'est-à-dire ton fichier memory.md et tous les fichiers associés. Il cartographie l'existant : quels fichiers existent, quelles informations sont stockées, quelle est la structure actuelle. C'est l'état des lieux complet avant toute intervention.

Phase 2 : Signal (analyse des transcripts)

En phase 2, Signal, Claude Code va "grepper" (analyser en profondeur) les transcripts de tes sessions. Ce sont les fichiers .jsonl qui contiennent l'historique de tes conversations. Il identifie les informations pertinentes, les décisions prises, les changements importants. C'est la phase de collecte d'intelligence.

Phase 3 : Consolidate (fusion et nettoyage)

La phase 3, Consolidate, c'est le cœur du travail. Claude Code va :

• Fusionner les doublons : si 3 fichiers disent la même chose, il les condense en un seul
• Convertir les dates relatives en dates absolues : "hier" devient "24 mars 2026"
• Virer les contradictions : Express supprimé, Fastify conservé
• Supprimer les notes obsolètes : debug sur du code qui n'existe plus, librairies abandonnées

Concrètement, ton memory.md peut passer de 280 lignes à 142. C'est une compression massive avec zéro perte d'information utile. Pour ceux qui pratiquent le vibe coding intensif avec des dizaines de sessions par jour, c'est un game changer.

Phase 4 : Prune (nettoyage de l'index)

La dernière phase, Prune, s'assure que l'index reste sous la barre des 200 lignes. Toutes les entrées obsolètes sont dégagées. Mais surtout, Claude Code va réorganiser par pertinence. Si tu utilises l'API Stripe dans 90 de tes 100 sessions, elle aura un poids plus important dans la mémoire. Tu peux même forcer ce comportement en demandant explicitement de pondérer certaines informations.

Comment activer le trigger automatique de /dream ?

Lancer manuellement /dream c'est bien, mais l'automatiser c'est mieux. Un développeur (Grandamenium sur GitHub) a créé un repo dédié avec un système de hooks qui déclenche automatiquement le nettoyage. Le principe est simple et repose sur deux conditions cumulatives.

Les conditions de déclenchement

Le trigger automatique se base sur de la logique conditionnelle avec deux critères qui doivent être remplis simultanément :

1. 24 heures écoulées depuis le dernier nettoyage
2. Plus de 5 sessions accumulées depuis le dernier dream

Si les deux conditions sont réunies, le hook se déclenche automatiquement. Tu fais un nettoyage à 19h, dans 24h et après 5+ sessions, un nouveau nettoyage s'exécute. C'est du "set and forget" : tu configures une fois, ça tourne tout seul.

Le script dreamhook.sh

Le repo contient un fichier dreamhook.sh qui s'intègre directement dans le système de hooks de Claude Code. C'est un script shell qui vérifie les conditions et lance la commande /dream quand c'est nécessaire. Si tu sais déjà installer Claude Code, ajouter ce hook est relativement simple. Le repo date de mars 2026, c'est donc très récent et aligné avec les dernières versions de Claude Code.

Pour l'installer, tu clones le repo, tu places le script dans ton dossier de hooks Claude Code, et tu t'assures qu'il a les permissions d'exécution. Le script gère tout le reste : vérification des conditions, déclenchement du dream, logging des opérations.

Quel est le résultat concret avant et après /dream ?

Passons aux résultats tangibles. Voici ce que /dream transforme concrètement dans ta mémoire Claude Code, comparaison directe.

Le memory.md optimisé

Avant /dream, un memory.md typique :

• 280 lignes (dépasse la limite de 200)
• Des mentions d'Express alors que tu es passé à Fastify
• 6 entrées qui disent "hier" sans aucune date
• Des notes de debug sur du code supprimé
• Des références à des librairies testées puis abandonnées

Après /dream :

• 142 lignes (bien sous la limite)
• API correctement référencée comme Fastify
• Dates absolues partout ("25 mars 2026 à 19h")
• Notes obsolètes supprimées
• 3 doublons fusionnés en un seul fichier condensé

C'est exactement le type d'optimisation qui fait la différence quand tu gères des projets complexes. Ceux qui utilisent l'automatisation IA au quotidien savent que chaque détail compte dans la qualité des outputs.

L'impact sur la qualité des sessions

Avec une mémoire propre, Claude Code retrouve sa pertinence. Il ne te propose plus du code basé sur des frameworks que tu as abandonnés. Il ne confond plus les timelines de tes migrations. Il ne perd plus de tokens à charger des informations inutiles dans sa fenêtre de contexte.

Le gain est double : meilleure qualité de réponse et économie de tokens. Quand ton memory.md est bourré de bruit, Claude Code gaspille une partie de sa fenêtre de contexte (même avec le million de tokens) à traiter des informations périmées. Après un dream, chaque ligne chargée en mémoire est pertinente et à jour.

Pourquoi la gestion mémoire est le prochain grand enjeu de l'IA ?

Ce sujet de la mémoire, c'est un problème à 1 milliard de dollars. Littéralement. Le prochain développeur qui sortira un protocole de gestion mémoire universel pour les agents IA sera milliardaire. Que ce soit un protocole, une méthode de fusion d'agents ou un standard ouvert, c'est le chaînon manquant de l'écosystème.

Au-delà de Claude Code

Le problème de la mémoire ne concerne pas que Claude Code. Tous les agents IA qui maintiennent un état entre les sessions font face au même défi. La commande /dream est une première réponse, mais elle reste spécifique à Claude Code. Pour ceux qui s'intéressent aux approches alternatives de gestion de connaissances, des solutions comme LightRAG et les graphes de connaissances explorent des pistes complémentaires.

L'idéal serait un système qui combine consolidation automatique (comme /dream), pondération par pertinence, et archivage intelligent des informations historiques qui pourraient redevenir utiles. On n'y est pas encore, mais /dream pose les bases d'une mémoire IA enfin gérable.

Les bonnes pratiques à adopter dès maintenant

En attendant la solution miracle, voici ce que tu peux faire immédiatement :

• Lance /dream régulièrement : au minimum une fois par semaine si tu es actif
• Configure le hook automatique : 24h + 5 sessions, c'est un bon ratio
• Vérifie ton memory.md manuellement de temps en temps : regarde s'il y a des "hier" ou "aujourd'hui" sans date
• Supprime les fichiers de debug quand le code associé n'existe plus
• Force la pondération : dis explicitement à Claude Code quelles APIs et quels patterns sont prioritaires

La mémoire propre, c'est pas glamour, c'est pas sexy. Mais c'est la différence entre un Claude Code qui te fait gagner du temps et un Claude Code qui te fait tourner en rond.

Meydeey — Architecte IA & Automatisation

+110 entrepreneurs formés au Vibe Coding et à l'automatisation IA. +28 000 abonnés YouTube.

YouTube LinkedIn Communauté