The Session Handoff Pattern

MULTIPLEX Cortex — patterns from building with AI, not writing about it

There’s a movie called Memento. The protagonist has anterograde amnesia. He can’t form new long-term memories. Wakes up every morning with no idea what happened the day before.

His solution: tattoos. His whole body is covered in them. Facts, names, faces, what he needs to do next. Every morning, he reads them. Every night, he writes new ones.

He controls what gets remembered. Not his brain. Him.

(If you’re Indian, you know this as Ghajini. Same concept, different abs.)

I think about this movie a lot when I’m working with AI coding tools.

The trap most developers don’t see

You’ve been building something with Claude Code, or Cursor, or Copilot for a few weeks. You have a long conversation going. Good progress.

Then one day you notice: the AI suggested something you already tried. You know you rejected it in an earlier session. You might have even written a comment in the code about why.

But the AI doesn’t know that. It forgot.

Or worse: you started a fresh session because the old one felt bloated. And now you’re re-explaining your stack, your database schema, why you chose Postgres over MySQL back in week one. Again. For the fourth time.

Both of these are the same problem. The AI controls what gets remembered. You don’t.

The Infinite Chat grows until the tool compacts it. Compaction is the AI summarizing your history into something it can fit in its window. The summary drops details. It drops your rejected approaches. It drops the reasoning behind your decisions. You lose context without knowing what was lost.

I had a session where compaction summarized “we tried Redis for caching and removed it, added latency with no benefit” as “evaluated caching options.” Next session, Claude suggested Redis again. The reasoning was gone. I spent an hour re-discovering why we’d already rejected it.

The Amnesia Reset avoids that by starting fresh. But you pay for it every session, re-explaining things that should be permanent.

Neither pattern compounds. You’re just treading water.

Four files

I’ve been running a different pattern for 60+ sessions across five production projects. It’s simple enough that I could explain it in a parking lot.

project/

├── CLAUDE.md      ← identity (who this project is)

├── NOW.md         ← state (where you are right now)

├── MEMORY.md      ← intelligence (what you’ve learned)

└── .claude/commands/

    ├── wake.md    ← start a session

    └── close.md   ← end a session

That’s it. Four files, two commands. (Starter templates on GitHub if you want to skip ahead.)

Before I go further: why four files and not one? Why not just a “notes.txt” you append to?

Same reason you don’t put your passport, your daily to-do list, and your diary in the same document. Different things have different decay rates.

CLAUDE.md is your project’s constitution. Stack choices, coding conventions, architectural decisions you’re committed to. This file changes rarely. Postgres over MySQL. TypeScript strict mode. Don’t use Docker. That’s the kind of thing that belongs here. Claude Code loads it automatically at the start of every session. You never re-explain your stack again.

NOW.md is your session handoff note. This gets completely overwritten every time you close. It’s not meant to accumulate. It answers one question: where was I? “Mid-refactor on the auth module. Next step: connect the token refresh logic to the rate limiter. Open question: do we need a queue here or is synchronous fine?” That’s the whole file. The next session reads it and picks up in 30 seconds.

MEMORY.md is the compounding layer. This one grows over time and never gets thrown away. “Approach X failed because of Y — don’t try it again.” “This API has a quirk: it returns 200 on failure if the payload is malformed, always check the response body.” “We tried Redis here in session 12 and it added complexity with no benefit.” These are the learnings you want to keep forever. The expensive lessons.

The commands are the ritual

Two commands. Thirty seconds each. This is the Memento habit.

/wake reads your three files and brings you back up to speed.

# wake.md

Read CLAUDE.md, NOW.md, and MEMORY.md.

Report: “Session N. Here’s where we are. Here’s what I know.”

Then pick up where we left off.

You pick up exactly where you left off. No re-explanation. No drift.

/close does the inverse. Before you end the session, you write what happened.

# close.md

What did we ship? What’s the next step?

Did we learn anything worth keeping?

Update NOW.md with the handoff. Append to MEMORY.md if needed.

NOW.md gets overwritten. MEMORY.md gets appended if there’s something new worth preserving. CLAUDE.md stays unchanged unless a major decision was made.

The commands are lightweight. The habit is what matters. Close properly, wake cleanly. That’s the whole thing.

What this changes

The before: re-explaining your database schema for the fourth time.

The after: “Session 47. /wake loads CLAUDE.md. Postgres, not MySQL, decided in session 12. NOW.md says I’m mid-refactor on the auth module. MEMORY.md has a note from session 23 that approach X doesn’t work because of Y. Picked up in 30 seconds.”

The difference is who controls memory. In the before, the tool decides what survives. In the after, you do.

It’s a structural shift. The AI is a collaborator with a short working memory. Your job is to be the one with the long memory. That’s what the three files are for.

A few things I’ve noticed running this

The pattern evolved. It started as three files. I added MEMORY.md after I found myself repeating the same expensive lesson across sessions. “Oh right, that API does that.” If I’d written it down the first time I wouldn’t have wasted the second hour.

NOW.md should be short. If it’s getting long, you’re using it wrong. It’s a handoff note, not a status report. I try to keep mine under 15 lines. The test: can I read this in 30 seconds and know exactly where I am?

CLAUDE.md earns its place over time. The first version might just be your stack choices. Over weeks it accumulates conventions you care about, patterns you’ve committed to, rules you’ve established with the AI. It becomes a working contract between you and your codebase.

MEMORY.md is the surprising one. After 60+ sessions, it’s become the most valuable file. Not because it’s long. Because every entry in it represents something that cost me real time once and will never cost me again.

The deeper thing

I was coaching a developer a few months ago. He was frustrated that Claude “kept forgetting.” I pointed out that Claude isn’t forgetting. It never had that information in a form that survives sessions. He was expecting the tool to do something it wasn’t designed to do.

The shift is this: you are the curator. Not the algorithm.

Native compaction is the AI deciding what matters. The Session Handoff pattern is you deciding what matters. That’s not a small difference.

Most knowledge work already has this problem. Important decisions get made on calls and never written down. Context lives in people’s heads and evaporates when they leave. AI coding just makes the stakes clearer. The context window is a hard wall.

The three-file system is one answer. Simple enough that you’ll actually do it. Structured enough that it compounds.

---

If you want to try this:

Get the Setup Guide + Starter Templates

15 minutes. Works today.

What’s your current pattern when you end an AI coding session? Does the next session pick up cleanly, or are you re-explaining?

---

MULTIPLEX Cortex appears monthly in AI Eating Software. It’s patterns from building with AI, not writing about it.