Warning Signs in the Middle of a Run
Most Claude Code sessions do not collapse in a single moment. They drift. The first five minutes feel sharp, the model reads files before it edits them, and every fix lands on top of the last one. Twenty edits later, the same test fails, the model is re-reading files it already summarized from memory, and you are explaining the project again in a message that is longer than the original task. That drift is the moment to stop and check whether the session is still an asset.
Watch for these specific signals:
- The model proposes a fix it already tried and rejected earlier in the same session.
- Error messages get pasted in three times in a row with only small changes to the surrounding code.
- It stops running tests and starts reasoning about what the tests probably say.
- Edits begin to undo other edits inside the same session.
- Your own instructions get longer while the plan gets vaguer.
- It claims to remember a file layout that no longer matches the repository.
One signal alone is noise. Three of them together mean the working set has gone stale, and no amount of patience in the next prompt will rebuild it.
Most teams push through the first signal because the task feels almost done. That almost is the trap: the remaining work usually looks small precisely because the session has stopped understanding the large picture.
The Real Cost of Pushing On
There is a tempting belief that persistence is cheaper than a restart, because the context is already paid for. It is not. Every follow-up turn re-sends the accumulated transcript, so a bloated session charges you for its own confusion on every retry. When you pay per token with a relay like SwiftRelay, the arithmetic is visible: each loop through a failing fix costs more than the last, and the output you get back is worse.
Pushing on also changes the shape of the code. Late-session edits tend to be defensive patches stacked on patches, made to satisfy an error the model no longer fully understands. You end up with conditionals that exist only to silence a test, and the original design intent is gone. The next engineer who reads the file cannot tell which branch is real behavior and which is scar tissue.
There is a third cost, the one you feel most: your own attention. Re-explaining constraints, re-checking assumptions, and re-approving edits that should have been obvious is the most expensive loop in the room. A long session is not free memory. It is a transcript, and a transcript is not a plan.
What a Clean Restart Actually Resets
A restart is not throwing away progress. The code stays in the working tree, the tests stay in the repository, and your git history keeps every change that mattered. What disappears is the noise: the abandoned attempts, the half-finished explanations, and the three versions of the same idea. What remains is what you choose to carry forward.
Write the handoff before you open the new session. Keep it to a page: the goal in one sentence, the current state of the branch, the files that matter, the failing command with its output, and the decisions already made. Five bullets of constraints beat fifty messages of history. If you want a cheap draft of that summary, a smaller model such as Claude Haiku 4.5 can turn the old transcript into the handoff while the main work continues on Claude Sonnet 5.5.
Then start the new session with the handoff as the first message and one instruction: read the listed files before editing anything. That single line restores the discipline that decayed in the old session. The fresh transcript is short, every token in it is relevant, and the model can hold the whole task in view again.
Side by Side: Pushing On and Restarting the Session
Put the two paths next to each other on the criteria that actually decide the outcome.
- Context quality. Pushing on keeps every dead end in view. Restarting carries only the current state and the decisions that still hold.
- Edit hygiene. Continued sessions accumulate defensive patches. A restarted session tends to redesign the small area that is actually broken.
- Token spend. Retries re-send the whole growing transcript. A restarted session starts narrow and grows only with real progress.
- Your attention. Long sessions demand constant re-explaining. Handoffs demand one careful write-up and then quiet.
- Recoverability. When a late-session fix fails, it is hard to say which idea caused it. A restart leaves a clean diff to reason about.
- Risk to the repository. Fatigued sessions revert working code. Fresh sessions start from a known good state and confirm it with a test run first.
The pattern is consistent: the restart wins whenever the session is looping, and the continuation wins when the task is still moving forward with each turn. If you can point at concrete progress in the last three exchanges, stay in the lap. If you cannot, the session is already costing you more than a pit stop.
The Green-Light Checklist and the Recommendation
Before you decide, run this quick checklist: is the last edit a genuine improvement, does the model still cite real file contents, is there a failing command you can hand over verbatim, and is the remaining work describable in five bullets? Three yes answers justify a restart. Anything less and you are guessing.
The recommendation is simple: restart by default once a session starts looping, and push on only while every turn produces a concrete, testable change. Treat the restart as a designed handoff, not a defeat. The two minutes spent writing the state of the branch come back as a clean working set and a diff you can trust.
Keep the restart cheap by keeping the interface simple. With SwiftRelay, Claude Code and Gemini CLI take the bare host, https://api.fastapirelay.com, while OpenAI-compatible SDKs add /v1 to the same endpoint. Billing is per token with no subscription, so a fresh and focused session is exactly the frugal move, and you can run the heavy reasoning on Claude Sonnet 5.5 without changing your tooling. New accounts receive a small gift credit, and inviting friends earns 14 percent of their top-ups, so experimenting with the restart habit stays inexpensive. If you want to try the workflow, sign up and point your client at the relay.