It forgets on purpose

Every session starts clean. Nothing from yesterday is in its head.

That is correct behaviour, and you would hate the alternative: a tool that carried forward every half-finished idea, every abandoned approach and every mistake from three weeks ago.

The fix is not a bigger head. It is written things it can go and read.

You already built most of it

In the main course, without calling it memory:

• CLAUDE.md, read every session, holding how you work
• bible/, holding what must not drift
• shots.json, holding the film itself
• LIBRARY.md, holding what you learned per project

Those are memory. This deck adds the tier for everything that does not fit in them.

One fact, one file

memory/
  MEMORY.md                       the index
  kling-drifts-on-long-prompts.md
  vertical-exports-need-safe-area.md
  restore-drill-caught-a-bad-archive.md

One file per thing. Not one enormous notes file, because a single file gets appended to forever and read by nobody, including the tool.

What a memory file says

---
name: vertical-exports-need-safe-area
description: Vertical crops lose the subject unless the safe area is set first
---

Automatic 9:16 reframing tracked the wrong subject on 6 of 40 shots and
did it confidently, in one pass, with no warning.

**Why:** it tracks motion, not meaning, and the moving thing is often
not the subject.

**How to apply:** reframe automatically, then look at every shot. Never
sample. Budget ten minutes for a 90 second piece.

The why and the how are the whole value. A memory that only records what happened teaches nothing next time.

The index gets too big to read

Here is the failure, and it is guaranteed if you do nothing.

You write one line in the index per memory. Ten memories, fine. Three hundred memories, and the index is now so large that reading it fills the attention that was supposed to go on your actual question.

At that point the memory system is actively costing you performance. It is not neutral, it is negative.

What that looks like

# MEMORY, index

## HARD RULES, always in context
- never-write-to-camera-originals
- always-restore-before-you-trust-a-backup

## TOPICS, open the one you need
- Generation and models (17)
- Delivery and platforms (9)
- The library and naming (12)
- Failures and what caused them (23)

The index grows only when a genuinely new topic appears. Add sixty memories about models and the index gains zero lines.

The two things that stay in the index

Only two:

• Hard rules. The handful where forgetting causes damage you cannot undo.
• Topic pointers. One line each.

Everything else is one level down, loaded when relevant and never before.

Searching beats reading

The index is a map. The way you actually recall something is to search the memories themselves:

"Search my memory for anything about vertical exports or reframing, and tell me what I already learned."

Then open the topic file for breadth, if you want the surrounding context.

Capture at the moment, not at the end

The memory you never write is the one you meant to write later.

"That cost me two hours. Save it as a memory: what happened, why, and what I should do next time. Then tell me which topic it went in."

Say it the moment it happens, while you still know why. A week later you remember the outcome and have lost the cause, and the cause was the valuable half.

The decay audit is the actual point

A memory that only accumulates gets longer. A memory that gets re-checked gets smarter.

"Read every memory in this topic. Which are now wrong, which are duplicates, and which have stopped being relevant? Recommend deletions. Change nothing."

Then delete what it found. A wrong memory is worse than a missing one, because it is confidently consulted.

Where memory must never go

Memories are plain files. They sync, they get committed, and on a system with agents they get read by things you are not watching.

Codename it or leave it out. "The client who needs 4K deliverables by the 12th" is a memory. The name is not.

Derived, never invented

The rule that keeps a memory honest:

"This would probably work better" is not evidence. A system that writes down what should be true and then obeys it has invented its own doctrine, and every contamination starts exactly there.

The exercise

Thirty minutes, and it pays back within a fortnight.

1. "Set up a memory folder with an index that holds hard rules and topic pointers only."
2. Think of the three most expensive things you learned this year. Write those first.
3. For each: what happened, why, and what to do next time.
4. *"Group my memories into topics and write a topic file for each. Keep the index to rules and

pointers."*

1. Add one hard rule you would never want forgotten.
2. "Search my memory for anything about naming." Confirm it finds things.
3. Put the audit in your calendar. Monthly. Deletions first.

What you should have now

• One file per fact, each carrying a why and a how to apply
• An index of hard rules and topic pointers that stops growing
• The habit of capturing at the moment it costs you, not later
• A monthly audit that deletes, not just reports
• Nothing secret anywhere in it

Your system now gets better at your job instead of just longer.