“If instead of correcting it, you rewind to the question you just asked and fill in the part it got wrong, it regenerates a clean answer — without all the confusing stuff. It doesn’t have to figure out ‘that’s wrong, and that’s wrong, but this is right.’ You keep high signal throughout the conversation.” — Lou
Session context: 2026-06-18_Mastermind — Bally asked how Lou keeps long conversations coherent; Lou demoed the rewind and fork controls and the habit behind them.
Core Idea
When the model misunderstands you, the instinct is to correct it in place: “No, you did that wrong, do it this way.” That instinct quietly poisons the conversation. Every wrong answer and every correction stays in the context window, so the model now has to reason around a pile of “that was wrong, and that was wrong, but this is right” — and that noise degrades everything downstream. Lou’s rule: don’t correct, rewind. Go back to the original query, edit it to include what the model missed, and regenerate. The bad attempt vanishes from context; the model answers as if it got a clean question the first time.
This sits inside a two-control distinction worth internalizing:
- Rewind replaces everything below your edit point within the same conversation. The bad branch is gone and unrecoverable — that’s the point. Use it to keep the main thread high-signal.
- Fork preserves everything above the split and starts a new conversation from there, leaving the original intact. Use it when a branch is interesting but divergent and you want to come back — or to run a derivative task (e.g., generate a teaching block) off a conversation without cluttering it, then delete the fork.
The governing principle is the same one behind compacting, handoff files, and /btw side-chats: a conversation is a working memory you are responsible for curating. Models read the whole context on every turn, follow a limited number of instructions reliably, and remember the beginning and end far better than the middle (the U-shaped memory curve). Failed attempts left lying in the middle are pure liability. Rewind is the cheapest way to take them back out.
Practical Application
Build the reflex: the moment an answer is off, do not type a correction. Hover the query that produced it, hit rewind (or edit), add the missing constraint, and resubmit. You’ll know you’ve internalized it when your transcripts stop containing “no, not like that” exchanges. Reserve fork for the case where the wrong-for-now branch is worth keeping; otherwise rewind and move on. And when a side-question tempts you mid-thread, use /btw so the detour gets its own context instead of bloating the main one.
Related Insights
- Insight - Control AI Reasoning Effort to Stop Context Pollution — same enemy (context pollution); this addresses pollution from failed attempts rather than over-eager reasoning.
- Insight - Fork vs Spawn — Decide Whether the Child Should Inherit What the Parent Knows — fork’s inheritance question; rewind is the in-place sibling that discards rather than branches.
- Insight - Forked Skills as Context Isolation — Run Sub-Agents Without Polluting Your Conversation — isolation at the skill level; this is isolation at the keystroke level.
- Insight - Explore the Whole Tree Before You Write the PRD — long adversarial explorations only stay useful if you keep them clean as you go.
Evolution Across Sessions
Complements the context-isolation family (Insight - Forked Skills as Context Isolation — Run Sub-Agents Without Polluting Your Conversation, Insight - Fork vs Spawn — Decide Whether the Child Should Inherit What the Parent Knows) by addressing the most common, lowest-tech pollution source: the in-line correction. It establishes the baseline practice — manage signal at the turn level by rewinding, not arguing — and names the fork-vs-rewind decision (preserve-and-branch vs. discard-and-continue) explicitly for the first time.