· Eric Brown
Every New Session Re-Litigates What You Already Decided
Claude Code starts each session fresh and compaction drops what was only said in chat, so dead ends get retried. How to make the next session start from them.
In October tcballard posted on X that "A new agent session shouldn't get a fresh vote on your architecture." His list of what the agent should know before it changes anything includes "Which shortcuts we decided weren't worth taking."
The big decisions (the database, the auth flow, which service owns billing) are the ones most likely to be written down somewhere. The votes that get re-cast every morning are smaller. The library you tried yesterday afternoon and backed out of. The refactor you're halfway through, and why you started it in that order. The obvious fix you didn't take, because you took it last week and it broke something else.
None of that is a rule, so nobody stops to put it in CLAUDE.md. It lives in the conversation, and a new session doesn't get the conversation.
Claude Code's memory docs say "Each Claude Code session begins with a fresh context window," and that what carries knowledge across sessions is CLAUDE.md files and auto memory. Compaction has the same gap inside a session. Claude re-reads the project-root CLAUDE.md from disk after /compact, and the troubleshooting note lists the reasons an instruction might vanish after compaction. The first one is that "it was given only in conversation."
So what happens to the dead end you ruled out yesterday? Mohammadi and colleagues, in a study of what coding agents do when the facts they need are missing, write that "A missing fact produces wrong work rather than absent work: an agent asked to act acts, fabricating the file or guessing the value." I'd put a dead end in the same category. The fresh session doesn't know you already tried the obvious approach, so it has every reason to try it again. It read the code, and the code doesn't say "we tried this."
Compaction makes it worse because you don't pick the moment. tonygwu described it as the "Most annoying thing in Claude Code / Codex: I get notified to come back to a session, then immediately hit compaction." The summary keeps the shape of the code. Whether it keeps "we ruled out the queue, and here's why" depends on what the summarizer thought mattered.
Anthropic's answer is to write it down. The best practices page says CLAUDE.md is the place for "Decisions that aren't in the repo," and hqmank gives the same advice: "keep requirements and architecture decisions in CLAUDE.md or task docs, with critical behavior covered by tests." For decisions that are settled and will stay settled, I agree.
A dead end from yesterday afternoon doesn't belong in a file every session loads for the next year. The same best practices page warns that every line in CLAUDE.md "takes a little of Claude's attention on every task." In my experience, once a line is in there it stays long after it stops mattering. Earlier this month I wrote about how rules files only grow, and a CLAUDE.md full of "tried X, didn't work" lines is how that starts.
Git doesn't catch it either, because most dead ends never get committed. You try the thing, it fails in ten minutes, and you back it out before anything lands.
What I ended up building
I ran into this on my own setup before we built anything for teams. I run a personal system on Claude Code that I'm in most of the day, and in August I got tired of losing the thinking. My save command ran at the end of a session and rebuilt what happened from memory, so anything a compaction, a crash or a /clear took before then was gone. (My design note from that week just says "we lose a LOT.")
The fix was one file, now.md, kept to one screen and overwritten every time the state actually changes. It has five fields: where to resume, the current bet, what's been ruled out, what's still open, and the exact next step. My note says the ruled-out field is there "so we don't re-run them." Each ruled-out line carries its reason, which is also how I can tell when one has stopped being true. Alongside the file is a tape, one line per decision or dead end, appended and never edited, so I can see how the day moved without rereading the transcript.
Writing it is the hard part, so I don't leave it to me. A line in CLAUDE.md tells the model to rewrite now.md and add a tape line whenever a decision lands, an approach dies or the hypothesis changes, because only the model can tell when that happened. Hooks cover the moments it's too busy to notice. If a burst of tool calls goes by and now.md hasn't changed, a hook reminds it.
Another hook puts the file back in front of the model. Claude Code's SessionStart hook fires when a session starts, resumes or comes back from compaction, and its output goes into context, so every one of those starts with now.md before I type anything. I tried a PreCompact hook first and couldn't get it to put anything in front of the model. The current hooks docs say a PreCompact hook's output becomes instructions for the compaction summary, so these days I'd add one of those too and use it to tell the summary what to keep.
What the next session should start with
Scout, the tool we're building, does the same thing for a team. Each person has a now entry with the same five fields, rewritten each time. Dead ends and decisions go on the tape as one-liners. Decisions that should outlast the week get recorded with a subject and a reason, and when one changes, the new entry replaces the old one as current while the old one stays in the history. At the start of a session the agent calls scout_session_bundle, which leads with conflicts, team rules and deprecations, then covers what changed since that person last read, teammates' current state, open handoffs and open work, capped around 6,000 tokens by default.
now and tape entries can be compacted after 30 days by default. A handoff with no ticket and no set expiry expires after 14 days, drops off the open lists, and stays in the history.
Scout has the same limit my file has. If nobody records the dead end, there's nothing to serve. The agent can write the entry, but somebody has to make sure the moment an approach got ruled out actually lands somewhere.
With or without Scout, I'd start here:
- Keep a short working-state file outside CLAUDE.md with resume, current bet, ruled out, open and next step. Overwrite it every time.
- Give every ruled-out approach one line and a reason. "Tried the queue, lost ordering on retries" is enough.
- Add a line to CLAUDE.md telling the agent to update that file when a decision lands or an approach dies.
- Add a SessionStart hook that prints the file on
startup,resume,clearandcompact, so every new session and every compaction starts with it. - When you compact by hand, tell it what to keep, like the docs' own example,
/compact keep the API changes and the test commands. - When a dead end hardens into a settled rule, move it into CLAUDE.md and take it out of the working file.
Later in the same post, tcballard writes, "We can change our minds. I just want that to be a decision too." If the next session tries the queue again, I want it to be because somebody decided the retry problem deserved another look.
Start the trial. 15 days. Every seat. Card up front, nothing charged until day 15. Plug into the record and stop repeating yourself to machines.