One Fact Per File — AI Automatic Memory (3)

Rules are the always-follow things. So where do you leave that trap that burned half a day last week?

The things rules can't hold

In the previous article we gathered always-follow rules into one file. But as you work, things pile up that aren't rules yet you'll surely need again next time.

• "This logger's timestamps are UTC; the DB is local time. Join them without converting and you get zero rows and no error."
• "In last month's analysis I suspected a faulty sensor, but the real cause was vibration from adjacent equipment."
• "This dashboard's address, this material's location."

Put all of it in the rules file and the file bloats, running up the cost of reading it every session for nothing. So you need automatic memory, separate from rules — a layer that accumulates reusable lessons, traps, decisions, and material locations, and loads them only when needed.

One fact per file — a principle that worked 90 years ago too

The core rule is simple. One fact per file, and one line of description in the index. Read only the index every time; open an individual file only when it's relevant.

This is no new idea. The sociologist Niklas Luhmann built a note box called the Zettelkasten over some 40 years, out of about 90,000 index cards. The rule was one idea per card, cards linked to each other by number. Thanks to that web of links he wrote more than 70 books and papers in his lifetime. Had he mixed several topics on a single card, he could never have found and reused them.

The same principle carries into modern knowledge management. Tiago Forte's Building a Second Brain proposed the CODE method — collect scattered notes and pull them out when needed — and tools like Obsidian stitch facts together with local Markdown files and bidirectional links (backlinks). What matters is that the memory an AI reads is, in the end, the same Markdown a person reads.

The research says AI needs "external memory" too

This idea shows up unchanged in AI research. As we saw in Part 1, an AI's context window is finite and is cleared when the session ends. So researchers proposed architectures like MemGPT (2023), which likens the context window to a computer's RAM and external storage to a disk. Facts are pulled in from outside and laid onto the context as needed, and what isn't in use is paged back out. The project now continues under the name Letta.

ChatGPT's memory feature (2024) and Claude's per-project memory come from the same concern. Either way, the gist is one: you can't hold everything at once, so keep it well organized outside and pull it in when you need it.

The structure of a good memory note

So a single memory file isn't just a fact thrown down — you build it like this.

• One-line description (index) — The AI decides whether to read it now from this one line alone. It has to carry the symptom and the condition.
• One fact — Don't mix two topics. If a file on the same topic exists, fix it rather than make a new one.
• Why — The basis and the backstory. With a reason, it applies correctly even in edge cases.
• How to apply — An action guide in the form of "when this happens, check that first."
• Links — Tie related memory together with links to widen the context.

One caution. Memory is a fact as of the time it was written. File names, paths, and settings change. Confirm that a name you pulled from memory still exists before using it, and if it conflicts with recent records, fix the memory.

What comes next

If rules and memory are the records the AI reads, the next article is about the records the me of the next session reads — Daily Notes and Handoff. There's also another series that unpacks the same theme at more length.

If you're at a loss for how to design your team's memory taxonomy, reach out via Contact. We'll put together examples tailored to your actual work.

---

The "Using AI as a Colleague That Remembers" series

1. Why AI Forgets Yesterday — Session Amnesia and the Cost of Context
2. Rules in One Place — How to Write an AI Rules File
3. One Fact Per File — AI Automatic Memory (current article)
4. To the Me of the Next Session — Daily Notes and Handoff
5. Promoted to the Team's Language — Trackers, Wikis, and Git
6. Pitfalls and a 4-Week Adoption Roadmap