Memory & knowledge

Memory compounding

Move memory out of the chat and into files a later session can actually read.

Paid $15 list, $12 until 2026-12-31 · one skill, yours for good. The outline, the steps and the file open after purchase.

Background

Thesis: prompts are one-shot; a loop executes continuously. The gap is not whether you can ask — it is whether, a day later, you still remember what you learned yesterday and the day before.

Why it must be externalized: memory kept inside a conversation rots — attention gets split, patterns get buried, and old notes keep being applied confidently on wrong premises. A conversation has a lifespan; a directory does not.

Why it is built this way

Memory lives in a directory of small files, because one big file replays the split attention it was meant to fix. The loop has three steps and the second one is the watershed: write as you go, stop and tidy, read before starting. Writing without tidying turns the directory into a dump, as rotten as memory inside a conversation, only relocated. Four rules keep it checkable: a date, a source, a status of observing or verified or retired, and archive instead of delete.

The skill spends its first section on how it will ever be triggered. Measured: it went 11 hours without one use after it was built, then three video sessions read memory/ zero times, which shows a rule with no attach point does not exist. So the trigger conditions sit in the description, the one line that enters the context every turn. The fix gate asks two questions before acting, and after the fix runs both criteria, the symptom and the reverse check.

Where it bites

• Two entries glued into one line Add-Content appends to the last line when the file does not end with a newline, and two records become one. memory_check.py misses it, because that line still opens with a valid format. The mandatory action before appending checks the trailing newline, and skipping it means the damage only shows at the next tidy-up.
• A rule that was never read The skill sat unused for 11 hours after it was built, and three later video sessions read memory/ zero times. Nothing was broken; read-before-start simply had no attach point. That measurement is why the trigger conditions live in the description, and why binding the rule to one production line was rejected as covering one class of task.
• A metric that cannot tell pass from fail Mean frame-to-frame difference scored smooth motion at 0.45 and jittery at 0.88, the same order of magnitude, so the criterion passed both. The coefficient of variation split them at 0.04 against 0.80. The rule: state what the number becomes when the thing is broken, or the criterion is invalid.
• A fix that breaks the next stage In one delivery project each fix was the root cause of the following round, four times over. The fix gate asks two questions first: what gets worse, and how it is measured. After the fix both criteria run, the reported symptom and the reverse check, and running only the first does not count as done.

When to use it

(Meta-level skill: spans all tasks, must not be bound to any domain.) Move memory out of the conversation into a readable/writable memory/ directory — before starting any non-trivial task, run memory_check.py --brief to read memory out, write as you go during the task, stop to verify and tidy, and get compounding smarter through the loop rather than through prompts. Use for lessons capture across conversations and tasks, long-running projects, and 'do you still remember what you learned last time' scenarios. Not for one-off Q&A (when there is nothing to carry across sessions).