You've felt it, even if you never named it.
Fifteen turns into a good session, the model is humming. Thirty turns in, something's off. It forgets the formatting rule you set at the top. It reintroduces a bug you fixed twenty minutes ago. It gets slower, vaguer, more confidently wrong. The conversation that was making you fast is now making you babysit.
So you improvise. You open a blank chat, paste in a quick summary of where things stood, and — relief — the model is sharp again. If you've done that, you've already discovered the thing this article is about. You just did it in a panic instead of on purpose.
I call it the Restart Method: treat an AI thread as a workspace you clear, not a diary you keep. It's a small shift in how you think about the tool, and it's the difference between compounding intelligence and compounding mess.
Why long threads rot
The mechanics
The instinct to keep one thread open forever is deeply human. We treat conversation as additive — every exchange makes the shared understanding richer. With a person, that's true. With a language model, it's a trap, for four concrete reasons.
01The window is finite.
A model doesn't "remember" your conversation the way you do; it re-reads the entire thing on every single turn, inside a fixed budget of tokens. A sprawling thread isn't a deeper relationship. It's a longer document the model has to re-skim before it can answer you — and the more there is to skim, the more thinly its attention spreads.
02The middle disappears.
There's a well-documented effect researchers named "Lost in the Middle": models pay the most attention to the very beginning of the context (your setup) and the very end (your latest message), and the least to everything between. That crucial decision you made on turn 14? It's now buried in the sag of the middle, right where the model looks least.
03Mistakes become canon.
Here's the quiet killer. When the model makes a small error on turn 12 and you don't catch it, that error is now part of the transcript — and on turn 30 the model treats its own past output as established fact. It's not reasoning from your intent anymore; it's reasoning from a record that includes its own mistakes. Correct it all you like; the wrong version is still sitting there, casting a vote.
04The slowdown is a symptom, not the disease.
Yes, a bloated thread often feels sluggish. That's mostly a compute cost, not proof the model got dumber — but it's a useful tell. When responses start dragging, treat it as a smoke alarm: the room is filling up.
None of this means the model is broken. It means you're asking a sharp tool to work in a cluttered room and wondering why the cuts aren't clean.
The thread is RAM, not a filing cabinet
The reframe
Here's the whole idea in one line. Your chat thread is active memory — RAM. It is not storage.
RAM is fast and volatile. You load it up to do work, and you clear it often to keep the work fast. Storage — the stuff you actually keep — lives somewhere durable: a document, a repo, a spec file. The mistake almost everyone makes is using the chat thread as both, trying to store their entire project inside the very place they're supposed to be doing quick, disposable work.
Once you separate the two — execution in the thread, memory in a document — the whole workflow changes. You stop being afraid to end a session, because ending it costs you nothing. The important stuff was never in the thread. It was in the file.
Extract, Terminate, Re-Inject
The method
The Restart Method is three moves. That's it.
1. Extract the state
Before you close an overloaded session, don't ask the model to "summarize the conversation" — that gets you a transcript, which is more noise. Ask it for an actionable state file. I use a version of this:
What comes back is signal with the noise boiled off — often a few hundred words standing in for tens of thousands.
2. Terminate the thread
Kill it. New blank chat, or /clear if you're in a command-line tool. This is the step people resist, because it feels like throwing away work. It isn't — you already extracted what mattered. And don't try to rescue a rotten thread by talking your way out of it; you can't reliably scrub context with more words. The clutter's votes still count until the thread is gone.
3. Re-inject and resume
Open the fresh session and load it deliberately: your role and constraints up top, the state summary in the middle, the next action at the bottom.
The new thread starts at full sharpness, holding only what's true and current. You've traded fifty turns of accumulated sludge for one page of pure signal.
Knowing when to pull the ripcord
The triggers
Half the skill is timing. You learn to feel the rot before it costs you an afternoon. The tells:
| Instruction driftIt's ignoring your rules | Formatting slips, constraints forgotten — your setup got buried under everything that came after it. |
| Hallucination loopIt's stuck | It keeps asserting the same wrong thing no matter how you correct it — the mistake is locked into the record and heavily weighted. |
| LatencyIt's dragging | The smoke alarm. Responses slow down as the context saturates. Time to check the room. |
| Phase changeYou've switched gears | You've moved from research to building, or drafting to editing. The scratch work from the last phase is pure clutter for the next — restart at every seam. |
That last one is the pro move: don't wait for rot. Restart on purpose at the natural seams of a project, and you rarely feel the rot at all.
In the wild
A case study
This isn't theory for me. My research lab runs a multi-month quantitative study — event-driven market analysis, a live data pipeline, a stack of statistical work that no single conversation could ever hold. Early on, I tried to run it as one long thread. It rotted exactly as described: by the end of a session the model was tripping over its own earlier output.
So the whole program moved onto the Restart Method. Every work session now ends by writing a state file — objective, decisions, what's mid-flight, what's next — and the next session starts fresh from it. Months of continuous progress, and there has never been a single "master thread." There's a chain of clean ones, each handing a tidy baton to the next.
The proof is almost too on-the-nose: the session I wrote this article in hit its own context ceiling partway through. It distilled its state, restarted, and picked up without dropping a stitch — repairing a stalled data feed, cleaning a dataset, and drafting a research paper across the seam. The method wrote its own case study while I watched.
The mindset
The takeaway
Strip it all down and the Restart Method is one habit: stop hoarding context.
The human instinct says keep the thread open so it remembers everything. The better instinct — the one that treats the tool like what it is — says the thread is scratch space; the memory lives in a document; clear the scratch space often to keep the work fast.
Decouple the two, and every prompt you write runs against a clean, dense, current context instead of a landfill. That's not a productivity hack. It's just working with the grain of the machine instead of against it — which, more and more, is the whole game.