Try this if
- An AI has forgotten a decision you settled earlier in the same session.
- Your tool has summarized a conversation on its own partway through a task, and the work got worse after.
- Skip it for short tasks that finish well inside the AI's context window.
A long working session with an AI starts sharp and ends vague. Deep into a task it forgets a decision you settled early on, tries a fix it already tried, or loses track of what you asked for in the first place.
That costs more than it seems, because nothing tells you it's happening. The tool doesn't warn you when the answers start slipping. It waits until the conversation is nearly full and then summarizes it on its own to make room, at the moment the conversation is at its messiest. You keep working from that summary without having read it, and the mess comes along.
The answer is to pick the moment yourself. Don't let one task run past half of the context window. At half, finish the step you're on, run your closing routine, a prompt that writes down what got done and what's left and saves the work, and start a fresh session from that note. It started as a working habit, and Thariq Shihipar, who works on Claude Code at Anthropic, explains why it holds in "Using Claude Code: session management and 1M context". "Due to context rot, the model is at its least intelligent point when compacting," he wrote, meaning the summary gets written by the AI at its worst.
The context window fills as you work
The context window is the AI's working space for one session. Every message and every file it reads takes up room in it. It fills as the session goes, and a task that reads a lot of files fills it fast.
You can see how full it is. In Claude Code, the AI coding tool that runs in your terminal, /context shows how much of the window is used and what's taking up the room. Other tools show a meter of their own, or none, in which case a long task is the signal. The meter shows how full the window is, not how good the answers are, which is why the line has to be set in advance.
Why half
The two ways to get it wrong don't cost the same. Stopping early costs you the time it takes to close a session and open another. Stopping too late costs you answers that slip as the window fills, and past that, work built on a summary nobody checked. With costs that lopsided, the safe side of the line is the one to be on, and half leaves plenty of room for the step you're finishing.
Half is a cautious cap, and nothing measured it. If your sessions stay sharp further than that, move the line out, or move it in if they slip sooner.
You could summarize the conversation yourself at half instead. Claude Code's /compact does that, and it's the better move for a long debugging session you can't stop in the middle. For everything else a fresh session wins, because it starts from a note written for a person to read, and you can check a note before the next session builds on it.
What to do at half
- Finish the step you're on. Stop between steps, not in the middle of one, so nothing is half-changed.
- Run your closing routine, which records what got done, what was checked and what's left, then saves the work to version control, such as a git commit. If you don't have one, Document what happened in your session before you and the AI forget sets one up.
- Start a new session and have it read that note before anything else.
What you get and what you don't
You get sessions that end before the automatic summary does, and a note at every break that tells the next session where things stand.
You don't get more done in one session. A task too big for half the window has to be split into steps that fit, and this won't split it for you.
Check /context or your tool's meter during your next long task, or watch the length of the task if your tool has no meter. When the window is half used, finish the step you're on and close the session.