How to Keep AI Coding Decisions From Getting Lost

You made a call three weeks ago. Use Postgres, not the document store, because the reporting layer needed real joins. You talked it through with your AI, weighed it, decided. Moved on to the next hurdle.

Today the same AI cheerfully suggests the document store to solve a different iteration of the same problem. It hasn't reviewed the code, or your project notes, it sees the problem in front of it, and doesn't have the context of the previous conversation. And unless you remember the reasoning well enough to re-argue it on the spot, you're either re-deriving a decision you already made or quietly adding a new dependency or tool to your stack to solve the same problem. Having AI write the code is easy. Keeping the decisions straight as the project gets large is hard.

Why do AI coding assistants lose your decisions?

The context window forgets, and every new session starts blind. Your AI doesn't carry the "why" from last month into today's session. It only knows whatever's in front of it right now. So the architectural calls, the tradeoffs you reasoned through, the "we tried that and it broke" lessons all evaporate the moment the session ends, or worse, get lost in the compaction.

That wouldn't matter as much if AI output were reliable enough to trust without checking. It isn't, and developers know it: in Stack Overflow's 2025 Developer Survey of more than 49,000 developers, trust in the accuracy of AI tools fell to 29%, down from 40% the year before. And an assistant that's confidently wrong does the most damage exactly where its memory fails, because a suggestion that ignores a decision you already made looks just as plausible as one that doesn't.

What does losing decisions really cost you?

It costs you the same work, twice, plus the risk of shipping a redundant dependency. When your AI can't remember the decision, you become the memory, and if you're like me, you're not very good at the job. You re-explain the constraint, re-justify the choice, or catch the regression in review if you catch it at all.

The survey puts a number on how often AI leads you back into that loop. The top frustration, cited by 66% of developers, is AI solutions that are "almost right, but not quite," and 45% say debugging AI-generated code eats more time than expected.

receipts

Stack Overflow's 2025 survey of 49,000+ developers found trust in AI accuracy dropped to 29%, and 66% named "almost right, but not quite" output as their biggest frustration, the exact shape a suggestion takes when it has forgotten a decision you already made. AI accelerates the typing and offloads none of the judgment. The developer still owns every decision, and now owns remembering them too.

An "almost right" suggestion that ignores a past decision is worse than a blank page. A blank page doesn't quietly add tech debt on top of an architecture call you made a month ago.

How do you keep AI decisions from getting lost?

Give the decisions a home outside the context window. Three approaches, roughly in order of effort:

1. Context files (CLAUDE.md and friends). Drop a file in the repo that states your conventions and constraints, and the AI reads it at the start of a session. Good for stable rules ("we use TypeScript everywhere, functional components only"). The limit: a static file gets stale, and it's the wrong shape for decisions, which are specific, dated, and reasoned. Your conventions belong here. The story of why you picked Postgres does not.

2. A decision log. A running record of the calls you've made and why. This is the highest-signal habit in the list, and the one people abandon first, because writing it up is work and you're busy doing the thing. A decision log only helps if keeping it doesn't depend on remembering to keep it.

3. Persistent AI memory. Tooling that captures decisions from the conversation itself, files them, and lets you search them later, so the record builds as a byproduct of the work instead of a chore bolted onto it.

That last approach is what we build at Scribld. You're talking to your AI anyway. When you make a call worth keeping, you say "scribble this down," and it gets filed into a searchable structure that survives across every conversation. The AI does the filing. You keep working. Later, "what did I decide about the database" returns the note, with the reasoning intact. No new app to open every morning, no copy-paste.

What belongs in a decision record versus a context file?

A context file holds the rules that are always true. A decision record holds a specific call, when you made it, and why. The test is whether it has a "because."

"We use Postgres" is a convention. It goes in the context file. "We chose Postgres over the document store on June 3rd because the reporting layer needed real joins and we'd rather not run two datastores" is a decision. It goes in the record, because six weeks from now the because is the part you'll expect the AI to remember, and the part it forgot in the first round of /compact.

FAQ

Does a CLAUDE.md file solve context loss?

Partly. It's great for stable conventions the AI should always follow, but it's the wrong tool for decisions. Decisions are dated and specific, and a static file doesn't capture the reasoning behind a particular call or when you made it.

Why does my AI contradict decisions I already made?

Because the context window doesn't persist between sessions. Unless the decision and its reasoning are in front of the model right now, the AI has no memory of it and will suggest whatever looks reasonable in isolation, including options you already ruled out.

Is losing AI context a real productivity problem?

Lost context rarely shows up by that name, it shows up as output that's almost right. In Stack Overflow's 2025 survey, the top frustration (66%) was AI that's "almost right, but not quite," and a suggestion that ignores a decision you already made is a classic way output lands there. The context didn't survive the session; the plausible-but-wrong answer did.

What's the lowest-effort way to start keeping decisions?

Capture the "because." Whether it's a decision log or a memory tool, the thing worth saving isn't what you chose, it's why. Skip the elaborate system and just record the reasoning behind calls you'd hate to re-argue.

Losing a decision feels small in the moment and expensive three weeks later, when you're staring at a redundancy you introduced about a topic you had settled months ago. The fix isn't a better memory. It's giving your decisions somewhere to live that the context window can't erase.

If you want that to happen without adding another chore to your week, that's what Scribld does. Your AI does the filing. You just keep building.