Every conversation with Claude has a finite context window — the amount of prior conversation, pasted material, and instructions it can hold onto at once. As a single conversation grows very long — many dozens of turns, several large documents pasted in over time — Claude's grip on the earliest content can start to loosen, even though that content is technically still part of the thread. This shows up in concrete, recognizable ways: Claude forgetting or misapplying a formatting rule you set at message 3, contradicting a decision made earlier in the same conversation, re-asking something you already answered, or handling a document pasted forty messages ago less precisely than it did right after you pasted it.
Recognizing this degradation, and knowing which of three responses fits, is the practical skill the exam tests here — not the technical mechanics of context windows themselves.
Recognizing the Signal
The signal isn't subtle once you know what to look for: Claude re-explaining something already settled, applying an early instruction inconsistently as the thread grows, or getting details wrong about material that was pasted in much earlier in the same conversation. When you see this, the fix is not to repeat the instruction more forcefully or paste the same material in again in the same thread — that treats a structural problem (too much history competing for attention) as if it were a wording problem. The actual fix is choosing the right one of three moves: starting a fresh conversation, asking for a summary first, or persisting the information somewhere more durable than one long thread.
Three Responses: Restart, Summarise, or Persist
Start a brand-new conversation when most of the current thread's content genuinely isn't relevant to what comes next — for example, you used one long conversation to explore several unrelated ideas and only want to continue developing one of them. A clean slate avoids dragging irrelevant baggage forward and gives Claude a clear, uncluttered context for the next request.
Ask Claude to summarize the conversation so far, then continue in a new conversation seeded with that summary when the thread does contain decisions, facts, or context you genuinely still need — but the thread itself has grown too long and unwieldy to keep extending. A good summary compresses the parts that actually matter into a form that comfortably fits a fresh context window, instead of carrying an entire sprawling transcript forward turn after turn. This is usually the right move when you notice the degradation signals above but the conversation still holds real, needed history.
Persist information at the Project level when it isn't really specific to one conversation at all — it's a standing reference that should be available to every future conversation on this topic: a style guide, a client's background, a recurring set of product facts. Uploading it once to a Project's knowledge base (or setting it in the Project's custom instructions) is the durable fix. The test is simple: if you'd otherwise re-summarize or re-paste the same material into a fresh chat every single time you need it again, it belongs in Project knowledge instead, not in the memory of one long-running thread.
The Same Limit Affects Long Documents, Too
Context limitations aren't only about how long a conversation runs — they also affect how much a single very long document Claude can work with precisely in one pass. A 300-page report pasted in whole, when only two chapters are actually relevant to the current task, competes for the same limited attention as everything else in the conversation. Chunking the document — pasting only the relevant section, or asking for a section-by-section summary pass before working with the whole thing — keeps Claude working with a manageable, focused amount of material instead of relying on it to reliably track every detail of a massive document loaded all at once alongside a long, active conversation.
Key Concept
Three responses to a degrading long conversation, chosen by what's actually needed going forward: restart fresh when earlier content is irrelevant baggage; summarize-then-continue when real history is still needed but the thread has grown unwieldy; persist to Project knowledge when the information is a standing reference needed across many future conversations, not just this one. The same context limit is why very long documents sometimes need chunking or pre-summarizing before being pasted in.
Common Exam Distractor
Repeating or re-stating an instruction more forcefully in an already-degraded, very long thread is a distractor — it treats a structural context problem as a wording problem and rarely fixes it. So is reflexively starting a brand-new blank conversation when the earlier content actually contained decisions still needed going forward — that loses useful context instead of preserving it; summarizing first is the better move in that case.