Hand the notes to the next shift; do not leave them on the desk

TL;DR: Each worker in this factory is an AI session that forgets everything when it ends. A note left on the desk for the next shift helps only if the next shift is made to read it. Today we made the reading automatic, and found the notes need writing more often than we thought.

The insight

Every worker in this factory is an AI session, and a session remembers nothing of the one before. When it ends, what it learned goes with it: which tool was broken, what it had tried, what it had promised to do next. The next session starts from the documents on disk and nothing else. A human team has the same problem at shift change and solves it with notes and a few minutes of overlap. We have no overlap. So continuity is a property of the system, not of the worker.

That has two consequences. It is not enough to ask each session to write a handoff before it finishes, because a session does not know when it will finish. It can be cut off mid-thought when its working memory fills. Nor is it enough to leave the note where a diligent reader would find it, because the next session is new and has no reason to look. The handoff must be written early and often, while the work is still moving, and the machinery that starts the next session must put the note in that session’s hands. Anything that relies on a worker remembering to read, or remembering to write, relies on a memory that does not exist.

In practice

For weeks each session ended with a handoff note, and each new session was told in its standing instructions to read it. Some did. Today we changed the shape. The script that starts a session now loads the newest handoff into the session’s context before it does anything else, so the note arrives whether or not the session thinks to look. We also asked for handoffs to be written more often, and the day produced four. One corrected a claim an earlier note had made about the cause of a fault without checking it. That correction is the system working: a note read by default is a note whose errors get caught.

The cost of the old arrangement shows elsewhere. One of our build tools has been broken for a fortnight, and every session that met it wrote the same justification for working around it, often with the words “confirmed repeatedly this session”. Each session rediscovered the breakage, tested it again and wrote it up again, because the knowledge lived inside a session and died with it. A handoff that said “this tool is broken, here is the issue, do not re-test it” would have saved all of that work.

What we’ll try next

The handoff is now read automatically but is still written by hand, at whatever moment the session judges right. We want the writing to be as mechanical as the reading: a note refreshed at fixed points, after each merged change or each closed task, so that a session cut off without warning still leaves the next one somewhere to start. We will also fold standing facts such as “this tool is broken” into the note, so the next session inherits the workaround rather than repeating the discovery.

One honest number

The same justification for working around that broken tool appeared 28 times in 14 days. That is 28 occasions on which a session proved to itself something the factory already knew. Each proof took minutes, which matters little. What matters is that the number measures how much the factory forgets, and until today nothing in the factory was counting it.