Originally written in French. Translated by AI — the meaning has been preserved, not the prose.
Angle
Giving a development assistant a memory does not consist in choosing somewhere to write: it consists in distributing five decisions — where the memory lives, what is retained in it, when it is tightened, at what cadence it is written, and when it is read back. Four of them automate without loss; the fifth, reloading, must remain a human gesture, because it is the only one that consumes the scarce resource of a session. A memory fails through this distribution long before it fails through its format: a badly distributed Markdown file is worth no more than a database, and a sound distribution works in both.
Synthesis
The starting problem looks like a storage problem. Claude Code forgets everything between two sessions, so what it ought to know has to be written down somewhere. The question seems settled as soon as the format is decided: Markdown files in the git repository rather than a hidden directory on the machine.
That choice in fact settles only one of the decisions, and it is the only one that is entirely reversible. The four others come up afterwards, and each of them arbitrates between a human and a machine.
What is retained is no longer designated by hand. A light model rereads each exchange and decides on its own what goes into the day's log and what rises into long memory. The decision has not disappeared: it has moved from gesture to text — a prompt, imposed sections, a deduplication instruction. That displacement is the most debatable point of the whole setup, because it contradicts a position better established elsewhere, according to which what gives a persistence its value is precisely that a human said "this counts". Both hold, but not for the same volume: you do not designate twenty exchanges a day by hand.
When it is tightened is not left to good intentions either. A ceiling of three hundred lines on long_memory.md triggers consolidation, and it is the size constraint — arbitrary, assumed as such — that produces the occasion to reread. Without it, upkeep remains an intention.
At what cadence it is written is imposed by the hook chosen, and the mistake begins there. A hook named Stop suggests the end of a session; it fires after every turn. That frequency then decides everything that is sustainable: the model chosen, the acceptable duration, the budget per run. A negligible threshold — less than a dollar a month — does not buy a saving, it buys the disappearance of a question, and an automation debated at every exchange ends up switched off.
When it is read back is the only decision that has not been handed over. Writing costs nobody anything; loading occupies the window of a session, and injecting a project's memory by default into a session opened for three lines degrades the answer. Hence /memory_load by hand, which looks like a limitation and is an arbitration.
What remains are the failures specific to this assembly, and they do not come from the format either. An automation that calls the very tool whose end it watches for wakes itself up. A utility agent launched from the project directory inherits that project's writing rules and stops returning the structure asked of it. Two design flaws, two decisions badly distributed between what the automation does and what it must recognize.
What the whole thing brings into view: a memory system is not judged on what it preserves, but on where each decision has been placed — and it remains possible to move all of them except the last.
Tensions / contradictions
The main contradiction bears on who designates what survives. A position established elsewhere holds that the value of a persistence lies in the gesture by which a human says "this counts", and that exhaustive preservation designates nothing; this system delegates that sorting to a model, according to a criterion written once. The dividing line is not settled: it seems to depend on volume and on tolerance for silent loss, but nothing here says exactly where it runs.
A second, less visible tension: the memory is written into the repository so as to be inspectable and correctable by hand, and it is produced at a cadence that makes such rereading improbable. Inspectability is real as a property, uncertain as a practice.
Questions
- How does a distribution of this kind transpose to a team, where the memory written by one becomes the context reloaded by another?
- What signal would make it possible to know that a delegated sorting criterion has started to discard what counted?