▶ YouTube Summaries

• YT :: https://www.youtube.com/watch?v=Jf54k7tFeEc
• Original title :: Turn off Claude Code's Memory

Theo audits the memories Claude Code has silently accumulated across his machines and finds them almost entirely worthless: on his main box, 45 memory files, a 3:1 write-to-read ratio, and 26 files never read once. He argues automatic memory is the wrong layer for encoding how a codebase works — code is the ground truth, and the correct places to steer an agent are architecture, CI, and a deliberately written AGENTS.md, in that order.

Code is the ground truth, memory is another thing to maintain

The video is built around a clip from Mario (creator of pi) talking with Armin (creator of Flask). Their position: for coding you don't want a memory system at all. The codebase already is the source of truth, it already evolves, and a memory store is one more artifact that drifts out of sync with it.

Theo extends this to comments and to the markdown plan files people now leave scattered in repos. Stale context isn't neutral dead weight — it actively steers both humans and agents wrong. The more you split knowledge across places, the more split-brain failures you get.

He also uses Cursor as evidence. Cursor built its business on sophisticated codebase-traversal and dynamic context feeding, and has since walked away from it: once models were trained to use bash and grep well, giving the agent tools beat building a fancy retrieval graph. Embeddings-and-ASTs context systems, he argues, are behind the curve and nobody who advocates them has run an eval showing they help.

Armin's counter-example is his Slack bot, which appends every prompt and response to a single JSONL log and queries it with jq — effectively infinite memory with no memory system.

Where memory does make sense

Theo concedes chat contexts are different. In a codebase there's a traceable path from a clicked button to every line it touches; in human problems there isn't — a question about a sore shoulder might legitimately connect to a keyboard purchase a month ago. So user-specific memory as tagging works there.

But he still dislikes memory that traps a model in a state: he blames GPT-4o's memory implementation for locking users into the model's sycophantic/psychosis-adjacent mode, and notes he routinely says "my friend has this problem" to stop ChatGPT dragging his own history into an answer.

The audit

Asking Claude Code what it remembered turned up: an abandoned spec he never intended to ship, a complaint that setting output style to concise didn't update the global file, per-PR numbers, benchmark-run details that pollute the very benchmarks he uses to test new models, notes about a Discord bridge tracking his washer and dryer, an out-of-date GitHub CLI he had already updated, and a plan comparison from three months ago.

Claude's own honest assessment was that maybe a third earns its keep, with three decay modes: redundant with AGENTS.md (already stated there before the memory was written), shipped feature designs that have expired, and point-in-time states that are actively risky because the drift got migrated or didn't, the PR merged or didn't, the leak got fixed or didn't. Theo's conclusion is to disable memory fleet-wide, archive, and delete.

What to do instead: Lauren's order of value

The framing Theo endorses comes from Lauren (potato, ex-React world, now at Cursor): every time you intervene to correct an agent, ask how to eliminate that intervention entirely. Work top to bottom and stop when the problem goes away.

1. Categorically eliminate the failure through architecture or data structures. End-to-end type safety (tRPC, Convex) deletes whole classes of bug for humans and agents alike; garbage collection and memory safety are the same move at a different level. Do this one hard, and if it fails, try again.
2. Turn it into a lint rule or a test that CI catches. Theo's example: T3 Code was shipping tens of megabytes over the websocket to load a thread. He optimized it, saw regressions within days, and added a CI check that replays real threads and comments the bandwidth per PR with a ceiling 30% above his optimized numbers. The payoff is that agents now fix the regression before reporting done.
3. Only then, reluctantly, a skill or a rule. These are a safety net, not a first reach, and are more useful for process (exposing a dev server over Tailscale) than for code.
4. Last resort: a human in the loop.

Two distinct goals

He separates two things people expect memory to deliver: fewer stupid mistakes, and the agent behaving as you want without being told every detail. Patching AGENTS.md after each failure addresses the first. The second requires stepping back and communicating not what you don't want done, but how you want the agent to think about what it would do. Fix directionality and most of the small annoying failures disappear on their own.

His AGENTS.md

Theo walks through the T3 Code file as a model of the alternative. It opens with what the product is and how it works — an agent that doesn't understand the product is as unpleasant as a teammate who doesn't. A "what makes T3 Code special" section states values: open at the core (models had suggested closed-sourcing parts), performance without compromise (a soft nudge that cut data-loading regressions more than any structural change), remote ready (otherwise agents build and test happily in Electron locally and break the phone), and multi-surface coverage. Then a glossary for shared vocabulary, a list of behaviors to stop (killing the running server), a hit-every-surface reminder, dev server and test data sections, verification rules against repo-wide checks, PR conventions, and a taste section capturing his and his co-maintainer's preferences: complexity at the adapter boundary, dumb UI, no unnecessary any or annotations, comments that describe usage and move with the code.

The bar he sets: your agent should understand you well enough that it regularly surprises you by going further in exactly the direction you wanted, or by pushing back in ways you'd have learned the hard way later. If that isn't happening, the tuning isn't done — and the files, not the memories, are what get you there.

Uncle Bob's line

Quoted from the source conversation and endorsed enthusiastically: it's probably a mistake to impose human discipline on an agent, but it's not a mistake to impose human values on it. The thresholds may need changing; the behaviors and disciplines shouldn't be forced across.