If you use AI every day, you've felt this: a long, productive conversation where the model finally "gets" you — then you start fresh tomorrow and have to re-explain everything from scratch. It's exhausting, and it makes AI feel less like a colleague and more like a goldfish with a graduate degree.
The good news: the forgetting is completely predictable, and once you understand the mechanism, the fix is obvious. Let's walk through why it happens and exactly what to do about it.
LLMs are stateless — that's the whole problem
Large language models like Claude, ChatGPT, and Gemini are stateless. That's a technical word with a simple meaning: the model itself remembers nothing between requests. Each time you hit send, the model processes your input, produces an output, and then — from its own perspective — forgets the entire exchange ever happened.
So how can it follow a multi-turn conversation at all? Because the interface quietly re-sends the entire chat history with every single message. When you type your tenth message, the app bundles up the previous nine messages plus your new one and ships the whole package to the model. The model isn't remembering — it's re-reading the transcript every time, from the top, as if for the first time.
The model has no memory. The chat window has the memory, and it's faking continuity by re-feeding the whole transcript on every turn. Understand that, and everything else makes sense.
Why the memory lives in the chat — and dies with it
If continuity is just "re-send the transcript," then your context only survives as long as that transcript does. Two things kill it:
- Closing the chat. Start a new conversation and the transcript is empty. The model is back to knowing nothing about you — not your job, not your preferences, not the decision you made together an hour ago.
- Filling the context window. Every model has a maximum amount of text it can hold at once (its "context window"). In a long session, older messages get pushed out or summarized away to make room. The thing you said at the start — "always write in British English," "I'm a tax attorney, not a student" — silently falls off the back of the truck.
This is why platform "memory" features feel hit-or-miss. ChatGPT's auto-memory and Claude Projects help, but they're vendor-specific, opaque, and out of your control. They decide what's worth remembering, they store it on their terms, and none of it follows you when you switch tools. You're renting a memory you don't own.
One context method, every issue.
SmarterContext is a free newsletter that teaches you exactly how to make AI remember — one field-tested method at a time. No fluff, no spam.
The fix: externalize your context
If the model has no memory of its own, the answer is simple: give it one you control. Instead of hoping the chat remembers, you write your context down once, in a structured file, and re-supply it whenever you need it. This is called externalized context, and it's the single highest-leverage habit for getting consistent AI output.
The file usually lives in a plain-text document — many people call it context.md. It captures the things you'd otherwise re-explain every session: who you are, your standards, your constraints, and your active work. Because you own the file, it works in any tool — paste it into ChatGPT, attach it to a Claude Project, drop it into Gemini or Cursor. One source of truth, every model.
A copy-paste context.md template
Here's a clean starting point. Fill in the brackets with your own details, save it, and paste it at the top of a new chat. That's it.
# MY CONTEXT ## Who I am - Role: [e.g. Senior financial analyst at a mid-market PE fund] - Experience level: [e.g. 12 years; deep in LBO modeling, light on code] - What I use AI for: [e.g. drafting memos, sanity-checking models, research] ## How I want you to work - Tone: [e.g. direct, no hedging, no filler intros] - Format: [e.g. bullet points over paragraphs; tables when comparing] - Length: [e.g. give the answer first, then the reasoning] - Always: [e.g. flag assumptions; cite your sources; use US English] - Never: [e.g. don't apologize; don't restate my question back to me] ## My standards & constraints - Non-negotiables: [e.g. numbers must tie out; no fabricated citations] - Domain rules: [e.g. follow GAAP; treat all figures as confidential] ## Active projects (update as you go) - [Project A]: [one-line status + what you need from AI] - [Project B]: [one-line status + what you need from AI] ## Decisions already made (so you don't re-litigate them) - [e.g. We chose vendor X over Y because of integration cost.] - [e.g. Target audience is CFOs, not individual investors.]
That's a complete briefing. A model that reads this before your first question starts informed instead of blank — and the difference in output quality is immediate and obvious.
From newbie to advanced: pick your level
Externalized context scales with how much effort you want to invest. Start at Level 1 today; graduate when you're ready.
Paste itBeginner
Keep your context.md in a notes app. At the start of any new chat, paste it in, then ask your question. Zero tools, zero setup, works in every AI on day one. This alone fixes 80% of the forgetting problem.
Pin itIntermediate
Stop pasting manually. Put the file where the tool auto-loads it: drop it into a Claude Project, paste the core into ChatGPT Custom Instructions, or save it as Cursor Rules. Now the context rides along automatically on every session in that workspace — no copy-paste required.
Retrieve itAdvanced
When your context outgrows a single file, split it into many — one per project, client, or domain — and let the AI pull in only what's relevant. This is RAG (retrieval-augmented generation): the system retrieves the right context chunk for each request instead of stuffing everything in at once. It's how you give an AI a whole library without blowing the context window.
One file you paste beats a brilliant prompt with no context, every time. Start there. Add automation later, only when the manual habit proves itself worth it.
Why this beats "just prompt better"
Prompt engineering improves a single task. Externalized context fixes a structural problem: the model doesn't know who you are across any task. You can write the perfect prompt and still get generic output, because the model has no idea you're a litigation partner and not a first-year associate. Context is the briefing you give before you say a word — and a well-briefed model makes every prompt you write more effective. The two compound.
Do this consistently and AI stops feeling like a goldfish. It starts every session already knowing your role, your standards, and the decisions you've made — because you handed it a memory it can actually read.