Three engineers made 10,140 changes in seven months. No one can hold that in their head. Neither can an AI that wakes up blank every morning.
A normal company keeps its memory in its people. Someone remembers why the refund rule is what it is, or which supplier let you down in spring. We have almost no people and a very forgetful assistant, so we had to do what large engineering teams do on purpose: write it down, in pieces small enough to read.
The test is two words. Someone opens a new session and types "Let's continue". It should know what we are doing, why, and what comes next.
The relay
Each person, on each line of work, has their own thread. A session ends by leaving a note. The next session on that thread starts by reading it.
Threads run in parallel and never overwrite each other. The list that points to the notes only grows: a new entry is added at the end and nothing is moved, so two people finishing at the same moment cannot collide.
What a session reads
Small pieces, in a fixed order.
The house rules.
How we work, what is never allowed, what the company is for. Changes slowly.
The map.
One short page that says which document to read for which kind of task, and how to find your own thread.
Your last note.
The newest wrap-up on your thread. This is where yesterday actually lives.
Everything else.
The current state of the company, the design notes, the old incidents. Read only when the task calls for them.
Anatomy of a note
The same shape every time.
A fixed template means the next session knows where to look before it starts reading.
The why, not just the what.
The code shows what was done. Only the note remembers what we were trying to do and what we rejected.
Open threads, in writing.
Unfinished work is the easiest thing to forget and the most expensive.
A letter to a stranger.
The last section is written to the next session as if it knows nothing. Because it knows nothing.
In numbers
What we learned
Memory is a thing you build.
One giant document is the same as none.
A session that has to read everything runs out of room before it starts working. Split the memory into pieces that each do one job.
Always read the same three things first.
A fixed starting point beats a smart search. Everything else is opened only when the task needs it.
End every session by writing the next one's first page.
The work is not done when the code works. It is done when a stranger could pick it up.
Add, never overwrite.
Parallel threads and a list of notes that only grows mean nobody's work erases anybody else's.
A small team cannot remember more than a big one. It can only write better.
Next · The story behind the system