Aller au contenu
Mastering Claude

Accueil / Une installation structurée

Une installation structurée10 minApplication

Brancher la mémoire de fichiers sur git

Un dossier de mémoire versionné par git, avec un remote privé et une règle de fusion qui conserve les deux contenus plutôt que de forcer, reste une technique à construire soi même, distincte de la mémoire automatique native qui, elle, ne quitte jamais la machine locale.

Un dossier de mémoire reste un tas de fichiers texte tant qu'il vit seul sur un poste : il disparaît avec la machine, et rien ne permet de savoir qui a écrit quoi ni quand. Le transformer en dépôt git change sa nature. Ajoutez un remote privé, et ce dossier devient un coffre synchronisable entre plusieurs postes, avec l'historique, le diff et la possibilité de revenir à une version antérieure que git apporte déjà.

Le protocole en quatre gestes

Le protocole tient en peu de mots. Au démarrage d'une session, tirez les notes distantes par un pull avant de lire quoi que ce soit d'autre. Écrivez ensuite pendant la session, comme un carnet ordinaire. En fin de session, validez les notes du jour par un commit, puis poussez vers le remote. Sur un conflit de fusion, la règle n'est jamais de forcer une version sur l'autre : elle est de conserver les deux contenus et de les fusionner à la lecture, à la main, un peu plus tard. Un dépôt jetable illustre la mécanique de base sans toucher à aucun dossier réel.

mkdir demo-memoire && cd demo-memoire
git init -q
echo "note du jour" > carnet.md
git add carnet.md
git commit -q -m "premiere note"
git log --oneline

Sur un vrai coffre, cette séquence se répète à chaque session, avec un pull ajouté avant l'écriture et un push après le commit. Un dossier passé au grep pour repérer un secret avant le tout premier push évite qu'un identifiant oublié parte sur le remote et y reste ensuite dans l'historique, même après une suppression ultérieure du fichier.

Ce que la mémoire automatique native ne remplace pas

Claude Code embarque désormais un mécanisme de mémoire automatique, distinct de CLAUDE.md, qui accumule seul des notes de session dans un dossier local. Ce mécanisme reste volontairement local à la machine : les worktrees et sous dossiers d'un même dépôt git partagent un seul dossier de mémoire automatique, mais rien n'est partagé entre plusieurs machines ou environnements cloud. Le protocole git décrit ici garde donc sa raison d'être précisément là où la mémoire automatique s'arrête, dès qu'un second poste ou un remote partagé entre en jeu. Les deux mécanismes répondent à deux besoins différents et peuvent coexister sans se gêner l'un l'autre.

Ce protocole prend tout son sens une fois relié aux événements du cycle de session, dans hooks et battement de coeur, où le pull et le push cessent d'être un geste manuel pour devenir automatiques.

Figure 1

Le cycle pull, écriture, commit, push

01
Pull
En début de session, tirer les notes distantes avant de lire quoi que ce soit d'autre.
02
Écriture
Ajouter des notes dans le dossier au fil de la session, comme un carnet ordinaire.
03
Commit
Valider les notes écrites avec un message qui date le lot.
04
Push
Pousser vers le remote privé en fin de session.
05
Conflit
Sur un refus de fusion automatique, garder les deux contenus et fusionner à la lecture, jamais forcer une version sur l'autre.
La figure montre l'ordre des quatre gestes du protocole et la réponse à apporter sur un conflit de fusion, garder les deux contenus plutôt que forcer l'un sur l'autre.
Figure 2

Deux mémoires qui ne se recouvrent pas

Garder une trace entre les sessionsPortéeDéclenchementCe qui y est écrit
Coffre mémoire versionné par gitPartagée entre tous les postes connectés au même remote privéManuelle par défaut, pull et push explicites, ou reliée à des hooksNotes rédigées à la main par l'utilisateur ou par l'agent sur instruction
Mémoire automatique nativeLocale à une seule machine, partagée seulement entre les worktrees et sous dossiers d'un même dépôt gitAutomatique, alimentée par le harnais pendant la session sans interventionNotes de session accumulées par l'outil lui même
Le tableau compare le coffre mémoire versionné par git et la mémoire automatique native sur trois critères : leur portée, ce qui les déclenche et ce qui y est écrit.
Calibrez vous-même

Une développeuse ajoute un remote privé à son dossier mémoire local, commite dix notes rédigées dans la semaine, puis lance git push vers ce remote depuis son poste principal. La commande se termine et rend la main.

Écrivez en une phrase ce que cette situation établit, et en une phrase ce qu'elle n'établit pas.

Ce qu’il faut retenir
  • Un dossier de mémoire versionné par git n'est pas une fonctionnalité documentée par Anthropic sous ce nom, c'est une technique de terrain construite avec les outils git ordinaires.
  • Sur un conflit de fusion du coffre mémoire, la règle est de conserver les deux contenus plutôt que de forcer l'un sur l'autre, puis de fusionner à la main.
  • Le dossier mémoire se passe au grep pour repérer un secret avant le tout premier push, jamais après.
  • La mémoire automatique native de Claude Code reste locale à la machine et ne se synchronise pas entre plusieurs postes, elle ne remplace donc pas un coffre git avec un remote privé.
À faire maintenant

Créez un dépôt git jetable pour votre dossier de mémoire, ajoutez lui un remote privé, poussez un premier commit, puis écrivez dans un fichier partagé la règle de fusion que vous appliquerez, garder les deux contenus, jamais forcer.

Vérifier à la source

Chaque affirmation datable de cette leçon renvoie ici au texte public qui la porte. Une source qui ne s’ouvre pas ne prouve rien.