I lost most of a day's work to a single sentence.
I was at work, deep in a long back-and-forth with Copilot on a training project, and the session just stopped. Froze. The thing I'd spent the afternoon building was sitting there half-finished, and there was no door back into the room where I'd built it. Now I have to start a new conversation with a complete stranger. It didn't know the project. It didn't know me. It didn't know a single thing the two of us had worked out together over the last three hours.
This was a few months ago. I didn't understand context windows then. I didn't know what a token was. All I knew was that these conversations had an end, the end showed up without warning, and everything on the far side of it was gone. Every new session started from zero. An island, with no way back to the last one.
So I built the way back by hand. When a session froze, I'd copy the whole conversation, paste all of it into a Word document, open a fresh session, attach the document, and say: read this, here's what we were doing, pick up where we left off. It worked. Mostly. Then that session would fill up and freeze too, so I made a second Word document. Then a third. Before long I had four of them, and attaching four documents to every new chat got to be its own kind of pain, so I combined the four into one. After that I just appended each dead session to the end of the one big file as I went.
I was keeping the machine's memory for it, by hand, in a Word document that never stopped growing.
That broke eventually. The file got so big the machine couldn't make sense of it anymore. But by then I'd already found the better move, and I'd found it because I could feel the wall coming before I hit it. I'd be deep in a session and an internal clock would start ticking: this is getting long. So instead of waiting to get caught out, I started getting ahead of it. Before a session could freeze, I'd tell it: this is running long, summarize everything we've done so I can carry it into the next one. A clean handover. I felt clever. Smarter than the wall. It didn't feel like I was building anything. I was just refusing to lose another afternoon.
The wall was waiting for me at home too. I'd started learning Python at night, and every new chat with my digital tutor opened the same blank way, no idea who I was or where I'd left off. So I wrote one prompt that explained who I was, what course I was taking, and what day of it I'd reached, saved it in a note on my phone, and pasted it into every fresh session. Something to carry in my pocket and hand over at the door.
The summaries piled up. "Summarize this for me" had become a reflex, and now I had a stack of them, with names like Session 5, that needed to live somewhere I could actually find them again. The project that pushed it over was a Google Ads account I was managing. I iterated on it across so many sessions that the summaries themselves turned into a mess, open questions in one, the answers in another, a decision in a third I'd reversed in a fourth. So I rolled five or six of them into a single running status document, one current-state file I could hand over instead of a pile. The same instinct as the Word docs, one rung up.
That stack of notes-to-self is also where my whole filing problem was born, and it sent me looking for a system. This is where I lost some time. I watched a lot of videos about organizing notes, and a lot of them turned out to be people who just like deep nested folders and pretty diagrams for their own sake. Productivity for the camera. That was never my problem. My problem was concrete and boring: I had context the machine needed and nowhere clean to keep it. I tried OneNote, and Copilot walked me cheerfully through setting the whole thing up as my permanent memory, then mentioned, once I'd built it, that it couldn't actually read OneNote very well. You just spent the last 45 minutes telling me this was the answer to everything! That was the day I started telling these tools: don't make things up, base it on what you can actually do.
I landed on Obsidian. Brainstormed a folder structure with the machine that promptly grew from four folders to nine. PARA turned into IPMADFRNA. The R wasn't even Resources anymore. I laid the famous note-graph on top. It's the one that's supposed to draw you a glowing map of all your connected ideas. The map was just a bunch of unconnected dots because making it work meant linking everything by hand and I had no patience for the busywork. It didn't matter. The folders were never the point. The point was the same as it had always been: a place to keep what the machine needed to know, so I could hand it over the moment a new session asked.
Then Claude Desktop added Projects, and right around the same time the chat started keeping a little memory of me between conversations. I could drop all those summaries into a Project and the next session would already know the context. I didn't have to introduce myself from scratch every time. The thing I'd been doing by hand for months, with Word docs and a phone note and a status file, was suddenly just part of the tool. The workaround had quietly turned into infrastructure.
And the second it did, it created a new problem, which is the part nobody warns you about. Once the machine remembered things, I had to get careful about what it remembered. I didn't want to ask it some throwaway question about which rowing machine to buy and have it bring up rowing machines a week later in the middle of real work. The problem hadn't gone away. It had changed shape. It kept changing shape every time I thought I'd solved it.
Somewhere in there I worked out what I'd actually been doing the whole time.
I wasn't building workarounds. I was building memory.
Every version of it, the Word doc, the phone note, the summary, the status file, the Project, came from the same instinct underneath: the machine should know who it's talking to, how I work, and what we've already done, and it should know it in a form that's short and specific instead of one giant muddied pile. That instinct turned out to be the whole blueprint. Everything I built after it, every agent in the system I run now, inherited it.
None of this was mine. It was never my private problem. Every one of these tools forgot, everyone who used them hit the same wall, and the whole industry is busy building the institutional version of my Word doc right now: shared context that follows you across tools, memory that persists, small specific instructions instead of one enormous prompt. I didn't see any of it coming. I just wouldn't keep starting over from a new island every morning. I'm still at it, too. At work, today, in Copilot, I'm still building the bridges by hand, because the wall is still right there.
The one wall that finally stayed up was never a piece of software. It was the habit of writing things down for the machine to read later.
Talking to it like a colleague who'll still be at the desk tomorrow, instead of feeling like I was waking up in Punxsutawney every morning.