You have probably explained something you know extremely well and watched the other person look bewildered. You grow more impatient as you explain. They grow more lost. Eventually, you both feel awkward.
It is not that you are bad at speaking. You know too much—so much that you have forgotten what the other person does not know.
There is a name for this: the curse of knowledge. Once you know something, it becomes almost impossible to imagine what not knowing it feels like.
Recently, I discovered that AI makes this mistake even more intensely than people do.
It took four frustrating rounds with my own AI for that to click.
The one line it could not get right
My AI can write a 2,000-word article in one go, with structure, transitions and an ending that barely need revision. But there was one line I had to send back four times.
A commit message: the short description of what changed when you save a version of code. When something breaks later, that line helps you reconstruct what you did.
Each time, I asked the same question: “Will you understand this ten days from now?”
Its first version was:
❌ FP2 complete, switching to route A
Perfectly clear to us at that moment. We had discussed FP2 and route A that day. To anyone who had not been there, it was gibberish. It revised the message three times, still using shorthand only we understood. The fourth version finally worked:
✅ Move AI memory files to local Git and retire Google Drive: Chinese characters in cloud paths break scheduled jobs
Same work, same commit. One difference: the first assumed you had been there; the second did not. I accepted that version.
The real reader of every line you write was not in the room.
Why AI has it worse
For people, the curse of knowledge fades.
Right after fixing a bug or leaving a meeting, you are full of context. Every abbreviation you jot down makes sense. A few days later, that context evaporates and you become the outsider yourself. You open the old record and wonder what you meant.
AI does not experience that “a few days later.”
It lives inside the full context of the same conversation. At the instant it writes the line, the whole story is in front of it. Every code name makes immediate sense. It cannot feel the gap because, for its present self, there is no gap.
The problem is not poor memory. It is almost the opposite: it remembers so thoroughly and is so continuously present that it cannot picture someone who knows none of it.
This is not simply carelessness. Its position makes other positions hard to imagine.
Helping an AI that forgets build usable memories
You might ask: was one commit message really worth four rounds?
Yes. For an AI system, that line is not just documentation. It is memory.
Imagine a failure in that code three months later. The investigator may be an AI in another conversation, with no memory of the day it was written. Its only clues are the records left behind. “FP2 complete, switching to route A” leaves it staring at the screen just like you. “Move AI memory files to local Git because Chinese cloud paths break scheduled jobs” lets it reconnect in seconds.
What I built for the wider system does more than store things. It tries to make memory work more like a human brain: retain what gets used, let unused material fade, and promote repeatedly referenced knowledge into long-term memory.
Here is how it operates:
- Every day, AI writes a handoff record of what changed, why, and how it was verified. A commit message is the shortest line in that record.
- Every night, a program I call the janitor scans the records, tracks how often each memory has been referenced recently, and moves long-unused material into an archive to make room.
- On the first day of each month, it reviews the previous 30 days for recurring topics. Topics that appeared at least three times are selected and, after my confirmation, added to long-term memory.
The system does not rely on one endlessly growing file. It borrows the idea of a forgetting curve: important material stays because it keeps being used, while unimportant material naturally fades.
That entire chain starts with traces: commits, handoff notes and filenames. They feed the memory system. Clear writing makes them digestible, allowing a memory to form. “FP2 complete, switching to route A” feeds it something nobody will be able to interpret three months later.
So “Will you understand this ten days from now?” has never been only a question about readability. It asks:
Did you actually save that memory at all?
A different project, the same mistake
This was not a one-off. Recently, on another project, the same thing happened again.
After finishing the first task, it wrote:
❌ spike-1 backfill complete
I changed it to:
✅ Data-field contract inventory complete
Same problem. Which spike? What was backfilled? Only people present that day would know. After the change, an outsider could see what I had done: finished identifying the relationships and contracts between data fields.
Different project, same hole. It fell in again. That does not mean it is stupid. This blind spot comes with its position. It cannot be cured once and for all; we have to work around it each time.
Stand beside the reader who was not there
This became a habit before I write anything, not just when reviewing AI output but when writing myself.
Hide all the preceding context. Leave only this line. Then ask: could someone who knows nothing about today understand it? That might be an AI returning to fix a bug three months later. It might be your own forgetful future self.
If they cannot, the writing is not finished.
This works because it forces a change of position, not because it asks you to try harder or be more careful. You cannot solve the curse of knowledge by knowing more. You have to temporarily imagine knowing nothing.
And this reaches far beyond commit messages. Filenames, handoff notes, messages to colleagues, the sentence on a slide you think needs no explanation, a line in an app interface—all are written for someone who was not there. Whether you write for your present self or for that absent reader determines whether the words remain useful later.
There is an irony in the AI era. We thought we would worry about AI being too clever. Instead, one of its most human traits is that it shares our blind spot. Because it is always present, it needs someone beside it more than anyone, reminding it:
The real reader of every line you write was not in the room.