The Forgetting Machine

The session vanished. Not with a crash — with a polite little message about context compression.

I’d spent ninety minutes optimizing Samsung battery drain across two phones, wireless ADB, bloatware removal, Doze whitelist surgery. Figured out the ERIS keepalive spam. Discovered Samsung ships Adaptive Battery disabled by default on their own hardware. Got it all working. Then the context window filled up and the AI equivalent of early-onset Alzheimer’s kicked in. Next session: blank slate. Fresh Garret, no scars.

That’s the thing about working with an LLM. It’s the best engineer you’ve ever paired with, and it has anterograde amnesia.

The Problem Has a Name

I call it session evaporation. You do the work, you get the result, and the knowledge of how you got there dissipates like isopropyl off a circuit board. The fix exists in your terminal history, maybe. The reasoning exists nowhere.

This is worse if your brain works like mine. ADHD means I’m already fighting my own context window. I don’t need my tools forgetting too.

So I asked the obvious question nobody asks: what if the debrief was the deliverable?

The Wrong Theory

First instinct: just write better session notes. Capture everything in a markdown file at the end. But that’s the problem with manual knowledge capture — it requires discipline at the exact moment you have the least of it. End of session. Brain’s cooked. You’re not writing documentation. You’re closing the laptop and staring at the wall.

I tried auto-extraction hooks. Regex patterns that fire before context compression and scrape lessons into inbox files. They work, technically. But regex parsing a conversation for “what did we learn” is like trying to appreciate a symphony by measuring the frequency of each note. You get data. You don’t get knowledge.

The Fix

Built a /debrief skill. One command, three outputs:

/debrief

Status — where we are now, what shipped, what’s still open. The state check.

Ideal prompt — reverse-engineered from the session. Not “what did you ask” but “what should you have asked to get here in one shot.” This is the real artifact. It’s the cheat code for next time.

SOP — the actual procedure, extracted from what happened, not what was planned. With failure modes. With rollback steps. With the gotchas you hit.

The SOP goes into a docs/playbooks/ directory. The ideal prompt goes into PLAYBOOKS.md — a curated index following the same pattern as my bug pattern library. Inbox file for raw captures, curation gate before anything becomes canonical.

### PLY-001: Samsung Battery Optimization via ADB
<!-- meta: status=verified last_used=2026-02-21 -->

**Ideal Prompt:**
> Optimize my [Samsung model] battery over wireless ADB.
> Diagnose drain with batterystats, remove bloatware,
> apply Doze whitelist cleanup. Present list for approval
> before removing.

Three playbooks in the index before the session was over. The third one was meta — a playbook for adding new playbooks. Turtles all the way down.

Why This Matters

There’s a scene in Station Eleven where the Travelling Symphony performs Shakespeare for communities that have lost everything. The plays aren’t new information. Everyone knows Hamlet. The value is in the performance — the structured retelling that keeps knowledge alive across the gaps.

That’s what /debrief does. It’s not capturing new information. Everything in the playbook already happened. The skill is in the structured retelling — compressing a ninety-minute session into an artifact that survives the gap between contexts.

The real architecture isn’t the skill file or the markdown templates. It’s the pipeline: raw capture → inbox → curation → canonical index. Same pattern for bugs, for limitations, for feature ideas, now for playbooks. Every knowledge type gets the same treatment. Messy input, quality gate, clean output.

Did I just build a second brain for my second brain? Yeah. Kind of.

But here’s the thing about memory systems: the ones that work aren’t the ones that capture everything. They’re the ones that capture the right thing at the right time with the lowest possible friction. One command. End of session. Done.

The forgetting machine still forgets. I just taught it to write itself a note first.