~/aakash
Writing ← Portfolio
Agentic AI November 12, 2026

I Don't Trust One Chat to Hold a Project

A chat holds the last hour, not the project, so over months it drifts and reopens what you settled. I keep the memory in plain files and an append-only decision log, and let each session read them fresh.

01

The afternoon it forgot

A few weeks into the project, an AI chat I had been working in all afternoon suggested, brightly and with good reasons, a thing we had already ruled out.

The project is a governance engine for regulated healthcare. Every action the system is asked to take comes back with one of three outcomes. We argued about the names of those three for longer than I would like to admit, and then we settled them: ALLOW, BLOCK, ESCALATE. Not DENY, not DEFER. It went into the decision log with an ID, and the words started turning up in specs, in tests, in emails to the client.

That afternoon I asked the chat to draft the response schema for the engine. It came back with ALLOW, DENY and DEFER. When I pushed on it, it made the case properly. DENY is what almost every policy engine uses, and anyone reading an audit log knows what it means. DEFER is a cleaner way to say not now, a human has to look at this. It was not a dumb suggestion, and that was the unsettling part. It made a reasonable case, close to the one that had been on the table before we chose other words, and it had no idea we had ever been there. The conversation where we decided had scrolled off hours ago.

I sat with that for a minute, because it landed somewhere uncomfortable. I had been treating this thing as if it were holding the project with me. It was not. It was holding the last hour, confidently, and calling that the whole picture. I only caught it because DENY looked wrong to me on sight. A little more tired and I would have nodded, the schema would have gone out, and in a compliance product the words are the contract. A reviewer who reads DENY in one document and BLOCK in another does not assume a typo. They assume two different behaviours.

The part that stuck with me came later. This was not the first time. That same vocabulary had to be locked in the log twice, once early and then again months on, because it kept leaking back in. Not from the people. From sessions that had never seen the first decision.

02

What it is actually bad at

We talk about AI as if the hard part is the thinking. The thinking is the easy part now, it is very good at that. The hard part, the thing it is quietly bad at, is holding a project still over time.

A project is not one clever answer. It is a few hundred small decisions made over months, each leaning on the ones before it, and the whole point is that they stay consistent with each other. That is the one thing a chat cannot do for you. Every session opens from zero. It does not remember what you decided on Tuesday, it remembers what is on the screen, and when the screen fills, Tuesday falls off the back of the truck.

So the failure is not that it gets things wrong. It is that it drifts, warmly and without noticing, and you do not catch the drift until it contradicts something you were sure was settled. Three words in a schema is the small version. The same mechanism reopens scope you closed, re-proposes an architecture you rejected, and forgets what you promised a client.

03

So I moved the memory out of the chat

The fix is almost embarrassingly plain once you see it. If the model cannot hold the project, stop asking it to. Put the project on disk, in files, and let the chat read them fresh each session and then forget. The conversation is the disposable part. The files are the project.

So the whole thing lives in a repository of plain Markdown, and the heart of it is one decisions log. Every entry has an ID, the decision, the reasoning, and the source, the exact email or meeting it came from. Nothing is ever deleted. When a decision changes, the old one is marked superseded and points at the new one.

It is past two hundred and forty entries now, and what it buys me is simple and a little magic. Eight months in, I can still answer why did we agree to that for anything on the project, by walking a chain of IDs back to an email. No chat I have used could do that. A text file does it without trying.

It also closed the afternoon I started with. The vocabulary rule now sits in the instructions every session reads before it touches anything, with both decision IDs next to it. The chat still does not remember. It no longer needs to. It reads.

The model is brilliant for an hour and blank by morning. The file is the memory it does not have.

And once the memory lives in files, the chat gets better at the thing it is genuinely good at, which is reading. A compliance question came in that decided real money: did a force override skip the mandatory approval step. If it did, it was a bug we owed. If it did not, it was scope the client would pay for. Because the code sits in a folder next to the docs, the session read the actual routes and found there was no approval gate for the override to bypass. A week of back-and-forth closed in an afternoon, because the answer was read, not remembered.

And the record catches me too, which is the part I trust most. We once sent the client a report built on the wrong baseline, a pre-contract estimate instead of the signed number. The client noticed. Because the contract, the report and the email were all in the same place, the fix was a day and a new decision, not a fight. It was embarrassing for an afternoon. Without a record to correct against, it would have been something worse than embarrassing.

04

What this really is

I should be clear about what this is. It is scaffolding. I am doing by hand, in files and a merge step and a stubborn append-only log, the thing I wish the tools just did: hold a project steady while I work across months. None of it is clever. It is a workaround for the one thing AI is worst at, and the day a model can carry a project's memory from one session to the next, a lot of this quietly goes away.

That day is not here. Until it is, the files are the difference between a project that stays coherent and one that slowly argues with itself, re-suggesting what you killed, renaming what you settled, forgetting what it owed. I trust the model to think. I do not trust it to remember. So I wrote the memory down somewhere it cannot lose, and I let the chat be what it is: a very sharp reader with no yesterday.

So: what are you trusting a single chat to remember right now, and has it already quietly forgotten it?