Every brand, article, and pipeline I run goes through Claude Code, which means every working day used to start with the same ritual: re-introducing myself to my own assistant. Who I am, what the four brands are, which rules are absolute, where the files live. Copy, paste, repeat — a tax paid in minutes and, worse, in generic replies, because an agent that doesn't know you gives advice addressed to nobody.
The fix is unglamorous and it works: plain text files that Claude reads automatically at the start of every session. No plugin, no database, no subscription — a folder of Markdown. I've run my entire operation on this for months. This post is the honest version of that system: the three files, the mistake that nearly sank it (with real numbers), and the three rules that saved it.
The system: three files and one habit
Claude Code automatically reads a file called CLAUDE.md from whatever folder you open it in. That single behavior is the whole foundation. Put your context in files next to it, tell CLAUDE.md what to read, and open Claude in that folder every time. That's the one habit: the system folder is the working directory, always. Forget that, and nothing loads — and you'll think the system broke when it didn't.
The minimal shape is three files:
| File | What lives there | When it's read |
|---|---|---|
CLAUDE.md | The map: what to read, where each kind of fact gets saved | Always, automatically |
hot.md | Constants: who you are, your rules, your red lines | Always |
MEMORY.md | Everything that changes: status, numbers, recent decisions | Always |
Everything else — deep context, per-project files, dated logs — gets created later, when needed, and read only when needed. Day one is three files, and that's a complete system, not a starter version.
One more habit turns it from a document into a memory: save at the moment, not at the end. When a decision lands or you correct Claude on something, ask it to record that immediately. End-of-session summaries get forgotten; moments don't.
The part nobody warned me about: memory gets fat
Here's what the tutorials skip, and it's the most valuable thing in this post. A memory system that works becomes a memory system that grows. Every session adds a few lines. Nothing ever leaves. And because the file is read at the start of every session, its weight is a tax you pay every single day — silently.
I know exactly how far this goes because I let it happen. My memory file reached 180KB. Loaded at session start, that's roughly 60–70 thousand tokens — about a third of the context window — burned before I typed my first word. And the punchline: most of that content was duplicated or stale. I was paying a daily tax to make my assistant slower and more distracted.
A memory with no size limit isn't a memory. It's a landfill with a read receipt.
The cleanup produced the numbers that reshaped how I use these tools: the always-read core went from 180KB to about 8KB — a 95% cut — and I ran a separate audit pass afterward to confirm that zero information was actually lost. It had all just moved to where it belonged: files that load only when asked for.
The three rules that came out of the wreckage
Rule 1: give the living memory a hard cap. Mine is 10KB, enforced as a rule Claude itself follows: when MEMORY.md approaches the cap, details move to a dated file in an archive folder, and a one-line summary stays behind. The archive grows forever and costs nothing, because it's never auto-read. The cap isn't a suggestion — an uncapped file will bloat again, because growth is what working memory does.
Rule 2: separate the constant from the changing. The always-read top (hot.md) holds only things that don't change monthly: identity, rules, red lines. Everything with a number in it lives in MEMORY.md, dated. The test is one question: will this be different in a month? The single most common corruption I've seen is a "constant" like "I have 12 products" — which becomes 15, silently, and now your assistant confidently asserts a wrong number forever.
Rule 3: write rules as judgment, not as lists. Current models infer behavior from principles remarkably well. Instead of seven commands about print resolution, one pair does more: Goal: every file that reaches the printer comes out sharp. Red line: nothing below 300 DPI ever gets uploaded. Long do/don't lists cost context every session and eventually contradict each other; a goal plus a red line generates the hundred correct behaviors you didn't think to list.
Traps I fell into so you don't have to
- One fact, two homes. Save the same fact in two files and they evolve in different directions — then Claude has to guess which is true. One home per fact; everything else points at it.
- Saving chatter. "Thanks", "sounds good", passing questions — if it won't matter in a future session, it doesn't get saved. Volume buries value.
- Building the palace on day one. My first instinct was ten tidy folders, most of which stayed empty. Empty structure is not organization; it's clutter with ambition. Start with three files and let need create the rest.
- Trusting the setup to survive sync folders. Keep the system somewhere permanent and boring on disk. iCloud's lazy file materialization and agents that expect files to just be there make bad roommates.
What this feels like after months
The honest benefit isn't the saved re-introductions, though those are real. It's that corrections compound. Every time I fix Claude's understanding of my work, that fix becomes permanent. The assistant I work with today carries months of accumulated corrections, preferences, and decisions — which means its output starts from my context, not from the statistical average of everyone's. That's the actual difference between a chatbot and a colleague, and it costs a folder of text files.
Everything above is enough to build it yourself tonight: three files, a cap, the constant/changing split, judgment-phrased rules, and the working-directory habit. If you'd rather skip the assembly, I packaged this system as The Claude Setup Guide — a 14-page illustrated guide, the templates pre-wired with all three rules, and a setup skill that interviews you and fills in your files ($13, and it exists in Arabic too, which is the version I built first). Both routes end in the same place: a Claude that opens every session already knowing you.
The Claude Setup Guide
The whole system from this article, packaged: a 14-page illustrated guide, the templates pre-wired with all three rules, and a setup skill that interviews you and writes your files for you.
Get the guide →Sources
- The 180KB file, the 60–70k token session cost, the 8KB result, and the zero-loss audit are measurements from my own system, July–August 2026 — measured, not estimated
- The Claude Setup Guide — my own product, disclosed above; the packaged version of this exact method
- Related build log on this site: What Two Automated Brands Actually Cost — the operation this memory system runs