Ethan. Email me
Writing · 2026-05-04

I disabled Claude’s auto-memory after a week.

I had been running an alternative for eight months — and I just open-sourced it.

Anthropic shipped auto-memory in Claude Code.

I tried it for a week. Then I disabled it.

Not because it was broken — it was working as designed. But I’d already been running a different memory system with my AI toolchain for eight months, and the contrast revealed something I think matters.

What I built instead is project-brain: an open-source project context protocol — with a Claude Code skill, scaffold script, and adapters for Cursor / Copilot / Codex CLI / Aider / Continue. v2.3.1 just shipped. The full unpacking is at the end of this piece.

This is what I noticed.


The test

Last week, Anthropic shipped a feature in Claude Code: auto-memory.

The setup is elegant. Claude Code observes your interactions, and over time builds up a memory folder in ~/.claude/projects/<project-id>/memory/ — files like user.md, feedback.md, project.md. Each new session starts with this memory injected into context. The system prompt explicitly encourages: “You should build up this memory system over time.”

I tried it for a week.


What I noticed

Five observations. None of them mean Claude’s design is wrong — but together they reveal a fork in the road for AI memory design that I don’t think gets enough air time.

1. Accumulation is incentivized; pruning is not

The system prompt encourages building memory over time. There’s no equivalent encouragement to prune it.

This sounds neutral. It isn’t. Asymmetric incentives produce asymmetric behavior. Over a week, my memory file grew. I noticed it accumulating preferences, error corrections, project facts. None of it triggered a “you should review and remove what’s no longer relevant” prompt.

The result: a slowly growing list of “don’t do X” entries. Each one was reasonable when written. The accumulation was not.

2. Each “feedback” entry is essentially “don’t do X again”

Claude’s memory has a “feedback” type, defined as: capture user corrections + capture user confirmations.

In practice, what gets captured is overwhelmingly the corrections — because corrections are signal-rich (“you got that wrong”), confirmations are signal-poor (“yes, looks good” is ambient).

After a week, my memory file was a collection of negatives. Each individually fine. Together: a cumulative defensive posture I hadn’t asked for and couldn’t see growing.

3. Auto-injection vs explicit invocation creates different qualities of attention

Claude’s memory is auto-injected into the system context every session. You don’t choose to load it — it’s there by default.

Compare that with a project root with a CLAUDE.md file that says “for this project, read these specific files at the start.” That’s explicit invocation. The AI sees structure, follows pointers, reads with intent.

Both work. They produce different qualities of attention. Auto-injection is convenient and uniform. Explicit invocation is structural and intentional. For long-running collaborations, I find the latter creates a healthier relationship with project context — the AI is reading something on purpose, not absorbing something passively.

4. There’s no separation between “tool calibration” and “working discipline”

This is the deepest one, and the hardest to articulate.

Claude Code’s auto-memory is designed to calibrate the assistant’s behavior to user preferences. Sensible product goal. But the mechanism — accumulated entries injected as default context — doesn’t distinguish between two very different categories:

  • Tool calibration: “User prefers tabs over spaces.” “User wants concise commit messages.”
  • Working-style discipline: “Always test before pushing.” “Never reset config without asking.”

The first is preferences. The second is practice — accumulated working principles that arguably should be revisited periodically rather than passively absorbed.

When the same mechanism handles both, the second category gets treated like the first: passive accumulation, no review cycle. Working discipline becomes a constraint list rather than a deliberately maintained practice.

5. Defense layers compound

When I noticed the accumulation problem, my first instinct was to add a meta-rule: “Be careful of accumulating reflexive constraints.”

That meta-rule is itself a reflexive constraint.

Memory systems that grow defensively + meta-rules to manage that defensiveness = recursive accumulation. There’s no natural floor. Every observation about the problem becomes another entry in the system.

The healthier move was the opposite direction: prune. Delete the entries. Trust real-time judgment over pre-loaded constraints. But the system isn’t designed to encourage that move.


The comparison

Dimension Claude auto-memory What I run
Loading Auto-injected into system context every session Explicit invocation via project-level CLAUDE.md
Content type Feedback corrections + preferences Project metadata: PROJECT / MAP / STATUS / DECISIONS / HANDOFF
Growth Accumulation only (no built-in pruning) Layered: STATUS rewrites freely (transient), DECISIONS append-only (permanent)
Boundary Tool behavior ≈ working discipline (conflated) Clean separation: tool calibration vs structural memory
Governance User must actively prune System has hard limits (STATUS 80-line cap) + scheduled MAP audits
Validation Used 1 week → had to reset 2 production projects validated + cross-window handoff stress-tested

This comparison is not meant to dismiss either approach. They’re coordinates on a map. Different shapes for different problems.


What I built instead

So: what was I running for those eight months that made the contrast so visible?

A folder structure I called project-brain. After today’s reflection, I open-sourced it:

👉 github.com/Ethan-YS/project-brain

One folder. Every session knows where you left off.

One brain/ folder. Five core files (PROJECT.md / MAP.md / STATUS.md / DECISIONS.md / HANDOFF.md). A small set of protocols. Designed so a fresh AI session can read 2-3 files and be productive — across new sessions, new windows, new collaborators.

v2.3.1 just shipped. MIT licensed. Validated across 2 production projects (Soul Engine migration + the launch of this personal site). Cross-window handoff mechanism stress-tested in real use.

It’s a layered offering — pick the parts you need:

  • A folder structure — brain/ with PROJECT / MAP / STATUS / DECISIONS / HANDOFF
  • A protocol — division of judgment, time-scale separation, problem-dimension classification
  • A Claude Code skill — install once (git clone … ~/.claude/skills/project-brain), then say “set up project brain” in any project
  • Adapters for Cursor, GitHub Copilot, Codex CLI, Aider, Continue (via AGENTS.md)
  • scaffold.sh — one command to bootstrap into any project
  • doctor.sh — read-only structural health-check (catches 6 documented traps; reports issues, never fixes them)

The README is the entry point. The case study (Soul Engine v1 → v2 + the launch of this personal site) is the receipt. There’s also a fully-filled example (examples/small-saas/) if the empty templates feel abstract.


Why this matters

Two design philosophies for AI memory:

  • Accumulation: capture everything, hope cleanup is rare, treat tool calibration and working discipline as a single accumulating layer.
  • Compounding: separate transient state from permanent decisions, separate tool memory from structural project memory, prune ruthlessly, build structure that earns its presence.

Neither is universally better. Auto-accumulation works for short-context, single-task tools. Compounding works for long-running collaborations where the AI carries judgment rather than just executing instructions.

Where you place that line — one-off tool vs. long-running collaboration — determines which design serves you. I think the industry is collectively figuring this out, and I’m contributing one data point: an open-source methodology, eight months of real use, and the receipts to back it up.

If you’re at Anthropic, OpenAI, Cursor, or any team designing AI memory: this isn’t a critique of your work. It’s a contribution to the conversation. The fork in the road is real, and we should all be choosing intentionally.