A project that remembers itself: memory for you, your successor and your AI
- Who it's for: anyone who works on several things at once, puts them aside and comes back later, or will one day hand their work to someone else. Programmers, but also people who never write code.
- What you'll take away: five principles for recording your work so nothing gets forgotten, and a simple way to start today without any special tool.
You know the feeling. You open a project that has been sitting in a drawer for six months and you have no idea why you put it aside. Did something not work? Did you lose interest? Were you waiting for something? And which of the half-finished parts are actually done, and which only look done?
Programming is no different from renovating a flat or dealing with paperwork. What costs the most is not what got lost, but what you have to figure out all over again.
It used to happen to me a lot. I work on many projects in the evenings and I deliberately switch between them, because I enjoy it and it clears my head. But every return cost me an hour of piecing together where I had left off. So I built a system that remembers it for me.
How it started: a project where everything has to be traceable
The first push didn't come from laziness but from a demanding hobby. On one project I set myself a strict rule: I would write everything myself from scratch and never look at anyone else's code, not even "just for a moment". This approach is called clean room development.
A promise like that only means something if you can prove it. So every formula needs a note about where it came from: a published paper, a standard, or my own derivation. Every decision needs a reason. And if something unclean does happen, it goes openly into an incident log and gets fixed. Nothing is swept under the rug.
I found that keeping an honest record like this helps far beyond that one project. It answers the questions I ask myself a year later about anything: where did this come from, why is it done this way, and what did we try before?
Who reads it
Originally I wrote mostly for myself. Over time it turned out the same record has three readers:
- me, six months later, when I don't remember a thing;
- the person who takes over the work or helps me with it, and has no time to read the whole history;
- the AI assistant I now do part of my work with. It has the same problem as a new colleague: every day it starts from zero and knows only what someone tells it or what it can read somewhere.
A good record serves all three at once. If it makes sense to someone who has never seen the project, it will make sense to me a year from now.
1. Write it down now, not "later"
The first rule sounded simple: keep notes on what you're doing as you go. In practice it didn't work.
On short tasks it held up. During long sessions, when you're fully focused on a problem, the note-taking quietly faded away. That was true for me and for the AI alike. When I properly checked it for the first time in July, 10 out of 16 entries were missing for a single day.
The lesson: a rule that is an extra step is the first thing to go when you're concentrating. Writing it down has to be part of the work itself. A task isn't done until it's recorded.
2. One source of truth
At first I tried writing to two places at once, just to be safe. It was the same mistake, only doubled: two extra steps, plus the question of which place is right when they disagree.
What finally worked was the opposite. Everything is written to one single place, and everything else is generated from it automatically. I built a small app of my own for this and named it Mímir, after the well of wisdom in Norse mythology. It holds a log, notes for each project and a list of unfinished things. Readable backups in plain files are created from it automatically.
It's also my notebook. When an idea strikes, at work, on the way somewhere or late in the evening, I open it on my phone and write the idea straight into the project it belongs to. Not on a scrap of paper that gets lost, and not into a general note nobody will find a month later. When I return to the project, the idea is waiting there with everything else.
Whether things are actually being recorded can be checked with one question: when was the last entry written?
3. Record what isn't anywhere else
The biggest mistake is recording everything. The record gets flooded, nothing important can be found, and you stop reading it.
Record what can't be found out any other way:
- decisions and their reasons: "not like this, because last time it broke during a power cut";
- dead ends: what we tried and why it didn't work, so nobody tries it again a year later;
- why something was put aside: it didn't work, we were waiting for something, or there simply wasn't any motivation. That's honest and useful information too;
- agreements: what can be done without asking and what can't;
- open issues: what we found but haven't solved yet.
Don't record what is visible in the work itself. In programming that's the code and its history; in a renovation it's the finished wall.
One question helps decide: will this still matter in six months, and is there no other way to find it out? If so, write it down.
4. Memory has layers
Over time it became clear that memory isn't a single notebook but several layers, each with a different job:
| Layer | What's in it | How often it changes |
|---|---|---|
| Who I am and how I work | habits, rules, pet peeves, the tools I use | rarely |
| Project rules | how the project is worked on, what's off limits, how results are checked | occasionally |
| Log and decisions | what was done, why, and what came of it | daily |
| Open issues | found but not yet solved. Nothing is deleted, only closed | daily |
Whoever comes to the project, me, a colleague or an AI, reads the first two layers first and then the latest log entries. They don't start from zero, but from where things were last left.
5. Link the record to the work
A small thing with a big effect. Programmers save every code change with a short description (a commit). In that description I add a link to the log entry that explains why. The code says what changed, the record says why, and the link connects them. When I come across an odd line a year later, one click shows me why it's there.
The same works outside programming: an entry number on an invoice, in the file name of a renovation photo or in an email.
The same rule applies when handing over work. When two people work on the same thing, or a person and an AI, or someone continues on a different computer, nobody has to read other people's conversations or ask around. Everyone reads the same record.
What still isn't perfect
So this doesn't sound too rosy:
- Entries still get skipped sometimes, by me and by the AI. That's why regular checks matter more than blind trust.
- Records go stale. What was true in August may not be true in November. When something stops being true, it gets corrected. I don't keep two contradictory truths side by side.
- More isn't better. Whatever gets read at the start has to be short. I once let that part grow too large and its end quietly stopped being read, without any warning. Since then it's only a short overview, and the details live in separate notes.
What changed
The biggest difference isn't technical. When I open a project that has been sitting for months, within a few minutes I know where I left off, why I put it aside and what is still open. Projects I would once have abandoned because there was too much to piece together, I now come back to and finish.
And whoever helps me with something, a person or an AI, doesn't have to start by asking "so how does this actually work?".
How to start, without any tool
You don't need your own app. This is enough to begin:
- One file or notebook per project with its rules: how it's worked on and what's off limits. Programmers put it in the project root (for example
README.md,CLAUDE.mdorAGENTS.md), where both people and AI coding agents will find it. - A decision log. Short dated entries: what we decided, why, and what didn't work out.
- A list of open issues. Never delete anything from it, just mark it done.
- Recording as part of the work. Not "when there's time" but "done means recorded". That goes for you, your colleague and your AI.
- A check now and then. My first check showed that more than half of the entries were missing.
Lately, ready-made tools have started to appear that do something similar, mostly for working with AI. That's a good sign: this isn't one person's quirk but a need shared by anyone who wants to be able to come back to their own work. The principles above apply whether you use an app, a spreadsheet or a plain paper notebook.