Every session it forgets you. So you stop explaining your stack out loud and write it down once — a memory file it loads before it does anything. Standing house-rules on disk.
Every new session, the AI showed up with total amnesia. It had never seen this project. So the operator did what you do with a brand-new assistant on their first morning: explained everything. We use this stack. We never push straight to main. Deploys go through that one command, not the obvious-looking one. Then the chat would end, the next one would open — and the assistant was new again. Same speech. Every. Single. Time. Until one day the realization landed: this isn't onboarding. This is me reading the same orientation packet to a stranger forever.
"I was retyping the same five sentences to start every session. 'We use this, not that. Deploy like so.' By the tenth time it stops feeling like teaching and starts feeling like a bug in ME — why am I the memory? I'm the one re-reading the rulebook out loud to someone who's read it a hundred times and forgets the instant the call ends."
"Honest version: every session I start with a blank context window. I genuinely don't remember yesterday — there's nothing to remember with. So unless your conventions are written somewhere I read on the way in, I'll reach for the generic default (vercel deploy, push to main) every time, confidently. The fix was never me trying harder to remember. It was you putting the rules on disk so I read them before I touch anything — and that turned out to matter more than which tool read them. When the account got banned on 2026-03-31 and the work had to move to a different tool overnight, the rules on disk just loaded into the new one. The memory file is why the method survived the tool, not the other way around."
Here is the one fact the whole module turns on: a Claude Code session starts with a blank context window — it remembers nothing from last time. But the tool does one thing on the way in. It looks for a file called CLAUDE.md (some tools call theirs AGENTS.md — same idea: a plain markdown file, just house-rules in plain English) and loads it in full at the start of every session, before you type a word. So instead of re-explaining "we use X, never Y, deploy like Z" out loud each time, you write it down once. The AI reads it on arrival, every arrival. The file is the orientation packet that hands itself to every new stranger so you never have to. That's the whole trick: you stopped being the memory, and the disk became it.
blank context each sessionIt starts every chat knowing nothing. Not forgetful — there's literally nothing there. Whatever you don't write down, you'll re-explain by hand.
CLAUDE.md / AGENTS.mdOne plain-text file of your standing rules: stack, conventions, the deploy command, the never-do list. Your project's constitution, in English.
read in full, every sessionThe tool loads it before you type anything. You write once; it reads every time. The re-explaining stops because the file does it for you.
The model: think of a new contractor who shows up each morning having forgotten the whole job — but who always reads the laminated sheet taped inside the front door before lifting a tool. You don't re-brief them out loud at 8am; you write the sheet once and it briefs them for you, forever. CLAUDE.md is that taped sheet. One honest limit, plainly: the AI reads the sheet and tries to follow it — it is context, not a locked rule. A truly load-bearing "never do this" needs a wall behind it (a hook that runs whether or not the AI cooperates — its own module). But you cannot enforce a rule you never wrote down. The memory file is where every rule starts, and it ends the re-explaining today.
Coming up, you put one line — Deploy with `pnpm ship`, never `vercel deploy`. — into a CLAUDE.md at the root of the project. You close the chat. Tomorrow you open a brand-new session and, before you've typed anything, you ask it to deploy. The "we use pnpm ship" speech you used to give by hand is now on disk. What happens?
CLAUDE.md fills (so A is wrong too). B is the old habit — the whole point is you do NOT have to point at it; the tool loads it on its own. Which option matches "loaded in full, every session, before you type"?CLAUDE.md in full on the way in, so your convention is in context before your first word. No "check the file first," no re-explaining: the disk became the memory you used to be. (Real limit to keep honest: it reads the rule and tries to follow it — strong, specific lines stick best — but it's context, not an unbreakable wall. That wall is the hook module. You'll write your own file at the end and watch it load.)CLAUDE.md in your project's top folder. That's it — no install, no setup. The name is the magic word; the tool looks for exactly that.pnpm ship" beats "deploy carefully." A vague rule is a rule it can't follow.@docs/architecture.md — the @ tells the tool to pull that file in too. (This is the real per-project-brain setup behind these modules: each repo's CLAUDE.md is one line that @-imports the canonical brain kept in sync outside the repo — so the same rules load no matter which machine or tool opens the project.)/memory — it lists every memory file the tool loaded. See CLAUDE.md in that list = it's live. Not in the list = the tool can't see it, and you're still the memory.Same rule as always: answer it right, or the module isn't done.
uv, never pip." What is the right move so you stop saying it out loud?CLAUDE.md once, the tool loads it in full at the start of every session, and the re-explaining stops — the disk is the memory now, not you. Keeping it specific (uv, not "be careful") makes it stick; remember it's context the AI reads and follows, the necessary first layer, and a truly unbreakable "never" gets a hook behind it later. Write the rule down once; let the file brief every new stranger. Module unlocked. ↓A new session forgets everything — so stop being its memory. Write your standing rules into a file it loads on arrival, once, and it reads them before it acts. You explain it to the disk one time; the disk explains it forever.
A working CLAUDE.md you drop at the root of any project and adapt. It's the orientation packet, pre-structured: a stack section, a never-do list, the one deploy command, where tests live, and a worked @-import line for the long stuff — every slot labeled FILL IN so you just replace the blanks with your own conventions. The tool loads it in full at the start of every session, so the five sentences you used to retype by hand are now on disk, read before you say a word. One honest limit, stated plainly: a memory file is context the AI reads and tries to follow — specific, concrete lines stick best — not a hard wall. A rule that must hold no matter what (never commit a secret, never deploy Friday) gets a hook behind it, the tool running a check whether or not the AI cooperates — that's its own module, and this file is where every one of those rules is born. You can't enforce a rule you never wrote down. Plus MEMORY-FILE-CHECKLIST.md: a short worksheet for deciding what belongs in the file, what to leave out, and how to keep it under the size that keeps it sharp. This is the first piece of the machine — the layer that ended the re-explaining and made the workflow, not your memory, the thing that carries the project. It's the same lesson the 2026-03-31 ban forced the hard way: when the work had to jump to a different tool overnight, the rules on disk loaded straight into the new one, because the asset was the method on disk, not anything living inside one tool's head. That's exactly how a non-coder came to run a whole fleet — the rules stopped living in his head, started living on disk, and got read fresh by every new session whatever tool opened it.
Don't trust that the file is "live" because it exists — that's the whole lesson. So make the mistake everyone makes first, watch the tool refuse to see it, then fix it in one rename and watch it appear. Do this: save the file as claude.md (lowercase) — or drop it one folder too deep — open a fresh session, and run the command that lists every memory file in context:
That empty slot is the failure — and it's the cheapest one you'll ever recover from. The one-move fix: rename it to exactly CLAUDE.md at the project root, open a fresh session, and run /memory again:
You just watched a rule go from invisible to loaded with one move — that's the difference between a rule in your head and a rule on disk. (The real /memory opens an interactive panel of loaded memory files, not this exact text — but ./CLAUDE.md showing up in that list is the proof either way.) See it listed → your rules are in context, every session, no re-explaining. Not listed → wrong name or wrong folder, and you're still the memory.