Your AI Work Evaporates in Chat. Your Notes Don't.

When you build something with an AI assistant, the real work is not the answer it returns. It is the prompt that finally worked, the spec you argued into shape, the decision you reversed at 1 a.m. All of it lives in a chat window that scrolls away. Keep that record yourself, in a vault you own, and it compounds.

Most people who build with AI today do not have a knowledge problem because they lack information. They have one because their information lives in the wrong place. The chat transcript is a conversation, not a record: searchable for a week, gone in spirit by the next session, locked to one vendor's interface and one account. The thread you spent a Saturday untangling is, by next month, a thing you vaguely remember having figured out once.

This is not a niche complaint. In Stack Overflow's 2025 Developer Survey, 84% of respondents are "using or planning to use AI tools in their development process" and 51% of professional developers "use AI tools daily." ¹ The work is real and repeatable now. The question is whether anything you learn while doing it survives the session you learned it in.

What most people believe: the tool remembers

The comfortable assumption is that the AI keeps your history for you. It is in the sidebar, after all, every conversation neatly dated. So the thinking goes that the record is handled, the tool remembers, and there is nothing to file. This belief is reasonable, common, and quietly wrong.

It is wrong in three ordinary ways. A chat history is a list of conversations, not a structured record of decisions. You cannot ask it "what did I decide about auth, and why," only scroll. It is locked to one vendor and one login; export it and you get a transcript, not a working artifact. And the model's own memory is a black box you cannot read, edit, or trust line by line. Stack Overflow found the trust gap directly: only 3.1% of respondents say they "highly trust" the accuracy of AI tools. ²

Prashanth Chandrasekar, Stack Overflow's CEO, named that gap as the survey's headline: "The growing lack of trust in AI tools stood out to us as the key data point in this year's survey, especially given the increased pace of growth and adoption of these AI tools." ³ You would not let an untrusted colleague be the sole keeper of the project's only notebook. The chat window is exactly that colleague.

Why the conversation is the wrong unit

The deeper problem is structural, not vendor-specific. A conversation is optimized for the next reply, not for the hundredth lookup. It rewards momentum and punishes return. Everything that made the work hard — the dead ends, the constraint you discovered, the prompt that finally landed — gets buried in the same undifferentiated scroll as the small talk.

Andrej Karpathy named the failure mode precisely when he published his "LLM Wiki" pattern in April 2026: in the ordinary chat-and-retrieve loop, "the LLM is rediscovering knowledge from scratch on every question. There's no accumulation." ⁴ That last sentence is the whole problem in four words. You are not building on yesterday's work. You are re-deriving it, paying the same cognitive toll twice, because the artifact that should have held the result was a transcript instead of a note.

The frustration shows up in the numbers. The biggest single frustration among developers using AI, reported by 66% of Stack Overflow's 2025 respondents, is "AI solutions that are almost right, but not quite." ⁵ An almost-right answer is precisely the kind you must remember the fix for: the edge case, the correction, the "actually, do it this way." If that fix lives only in a chat you will never reopen, you will hit the same almost-right wall again next week, and solve it again from scratch.

The argument: keep the record yourself

The fix is old and unglamorous. Keep your own durable, human-readable record of the work as you do it — the prompt that worked, the decision and its reason, the output worth keeping — in a plain format you own. Not the chat. A note. The conversation is where the work happens; the note is where it stays.

This is the same principle that makes plain-text files outlast the apps that open them. Steph Ango, who runs Obsidian, put it plainly: "In the fullness of time, the files you create are more important than the tools you use to create them. Apps are ephemeral, but your files have a chance to last." ⁶ An AI chat is the most ephemeral app surface yet — a stream, not a store. The note you copy out of it is the only part with a chance to last.

And kept this way, the record does something a transcript never can: it compounds. Karpathy's term for a markdown store the model reads and maintains is exact — "the wiki is a persistent, compounding artifact." ⁷ The professional version of this discipline already has a name in software. Thoughtworks named spec-driven development one of 2025's key new AI-assisted engineering practices ⁸: writing "well-crafted software requirement specifications as prompts" ⁹ that the AI builds from — and that you keep, version, and refine, rather than re-explaining your intent in a fresh chat every time.

The practice: a project log you own

Here is the concrete move. For any small thing you build with an AI, keep one folder of plain-text notes alongside the work and capture four things as you go: what you are building and why, what you decided, the prompts that earned their keep, and the outputs worth saving. Four files, not a system.

A project log is a folder like this. Nothing to install, readable in any text editor, yours to keep:

my-project/
  spec.md          # what you're building and why — the brief you give the AI
  decisions.md     # dated log: what you chose, what you rejected, and the reason
  prompts.md       # the prompts that actually worked, with a one-line note on each
  outputs/         # the AI results worth keeping — drafts, snippets, copy

And a decisions.md entry costs you one minute and saves you the re-derivation:

## 2026-06-19 — Auth approach

Decided: magic-link email, no password.
Rejected: OAuth-only (didn't want to require a Google/GitHub account on day one).
Reason: lowest-friction sign-in for a first version; revisit if abuse appears.
Prompt that helped: "compare magic-link vs OAuth-only for a solo side project,
optimizing for sign-up friction and maintenance cost" — see prompts.md #4.

Three rules keep it from rotting. Capture in the moment, not at the end — paste the winning prompt the second it works, because you will not reconstruct it later. Date everything, so the log reads as a timeline you can trust. And write for the version of you who forgot — one sentence of why is worth a page of what. To wire a vault like this directly into the AI — so the model reads your own notes before it answers — there is a companion piece on using markdown notes as AI memory.

What this is not

This is not a second brain, and it is not a productivity system to perfect. A project log is scaffolding for one build, not a cathedral. If the project ends, the folder is an honest record of how it went. If it continues, the AI has a memory it can read instead of a history it cannot.

It is also not an argument against using AI heavily. Use it as much as the work rewards. The claim is narrower and harder to dismiss: the value you create with an assistant is only as durable as the place you put it. Put it in a chat, and it evaporates on the vendor's schedule. Put it in a plain-text file you own, and it is still there — searchable, portable, editable — long after the conversation that produced it has scrolled into the dark.

Frequently Asked Questions

The short version is one rule: keep your own record. The questions below cover what to capture, in what format, and whether the AI needs to read it. Every answer returns to the same point: work you do with an assistant is only as durable as the place you put it, and a chat is the least durable place.

Why not just rely on my AI chat history?

A chat history is a list of conversations, not a structured record of decisions. You can scroll it, but you cannot query "what did I decide and why." It is locked to one vendor and one login, and exporting it yields a transcript, not a working artifact. A plain-text note you keep is searchable, portable, and yours regardless of which tool you used.

What exactly should I capture from an AI session?

Four things: the spec (what you are building and why), decisions (what you chose, rejected, and the reason), the prompts that actually worked, and outputs worth saving. Skip the small talk and the dead ends that led nowhere. The test is simple: if forgetting it would cost you an hour next week, write it down now.

Isn't this just extra busywork on top of the real work?

A decision entry costs about a minute and saves the re-derivation later. The 66% of developers who hit "AI solutions that are almost right, but not quite" ⁵ pay for the fix once when they find it and again when they forget it. Capturing the fix in the moment converts that recurring tax into a one-time cost. Capture only what you would hate to lose.

What format should the project log be in?

Plain text, in markdown. It is human-readable, opens in any editor on any device, and is the format AI assistants read most cheaply, so the same notes that help you also help the model. Avoid anything that locks the record inside one app's database, because the whole point is that the record outlives the tool.

What is spec-driven development, and do I need it?

Spec-driven development, named by Thoughtworks as a key 2025 practice ⁸, means writing a clear specification first and having the AI build from it, rather than inferring your intent from scattered prompts. For a side project you do not need the formal version; a one-page spec.md you keep and refine is enough to get most of the benefit.

Does the AI need to read my notes for this to be worth it?

No. The first benefit is for you: a record you can return to. The second, optional benefit is pointing the AI at the folder so it reads your own notes before answering, which turns the log into a memory the model maintains. The capture habit pays off either way; wiring it to the AI is a bonus, not a prerequisite.

Where should the vault live?

Anywhere it is plain text and under your control: a local folder, a synced directory, a git repository. Local-first storage on your own device keeps the record private and available offline, with no account standing between you and your own notes. The requirement is ownership and an open format, not any particular product.

The chat window is where you think with an AI. The vault is where you keep what the thinking was worth.

If you want that vault to live on your own device — local-first, in open Markdown, with nothing between you and your notes — mnmnote.com runs in your browser.