- In short
- When detailed instructions given early in a long session no longer hold much later, the correct diagnosis is context compression -- the instructions lost force as the window filled -- not Claude disregarding them. That diagnosis then determines whether to restart, summarise, or persist. Breaking a large task into smaller segments with interim knowledge-base saves reduces exposure to this failure mode, and planning segment boundaries in advance is a stronger strategy than extending a single session indefinitely.
The capstone diagnosis
This knowledge point is where the whole context-management task statement comes together. The CCAO-F exam tests it at the evaluate level: given a long session where early instructions no longer hold, can you correctly diagnose the cause, choose the right response, and recognise the better upfront strategy? It draws on recognising degradation and choosing between restart and summarise and turns them into a single judgement.
The scenario is specific and common: detailed instructions given at the start of a long session lose force much later in the same session. The evaluative move is to attribute this to context compression -- the instructions were condensed as the window filled -- rather than to Claude deciding to disregard them. That diagnosis is not academic; it determines which response fixes the problem and points toward a prevention strategy that avoids the failure entirely.
- Diagnosing a long-session context failure
- Correctly attributing the loss of early instructions late in a long session to context compression -- the instructions lost force as the window filled -- rather than to Claude disregarding them. The diagnosis determines whether to restart, summarise, or persist. Segmenting a large task with interim knowledge-base saves reduces exposure, and planning segment boundaries in advance beats extending one session indefinitely.
Diagnosing correctly
The correct diagnosis rests on a single observation: the instructions were followed at the start and stopped being followed later, in the same session. That timeline rules out the model never understanding them -- it plainly did, early on. What changed between early and late is not the model's grasp of the instruction but the state of the context window, which filled over the session and compressed the earliest content, the instructions included. So the loss of force is compression, not disregard.
Getting this right matters because the two diagnoses point to opposite actions. If you conclude the model is disregarding instructions, you will try to make it comply -- often by repeating the instruction in place, which is the very trap to avoid, because it treats a context-state problem as a compliance problem and does nothing about the filled window. If you correctly diagnose compression, you address the context state instead: restart, summarise, or persist, chosen per the three responses and the restart-versus-summarise judgement. The diagnosis is what makes the fix land on the real cause.
Choosing the response and preventing recurrence
Once compression is diagnosed, the response follows from the earlier analysis. If the thread is still coherent and worth continuing, summarise the state and restart into a fresh window so the early instructions -- captured in the summary -- are back in active context. If the session has drifted beyond recovery, restart clean. If the instructions are the kind that should hold across every session, persist them to Memory or the knowledge base so they survive indefinitely. The diagnosis selects among these; it does not leave you repeating yourself into a full window.
Better still is preventing the failure before it happens. Breaking a large task into smaller segments, with interim saves to the knowledge base at segment boundaries, reduces exposure to compression because no single session runs long enough to fill and compress critically. Planning those segment boundaries in advance is a stronger strategy than extending one session indefinitely and hoping the window holds. The evaluative insight is that the robust practice is architectural -- design the work into segments -- rather than reactive. This is the same segment-and-save discipline that supports persisting durable facts.
What the CCAO-F exam trips candidates on
Two errors are tested. The first is concluding the model changed its mind about instructions rather than recognising context compression as the cause. The credited reading uses the early-followed-then-dropped timeline to identify compression and rejects the "model disregarded it" framing.
The second is responding to the symptom by repeating the same instruction again in place instead of addressing the underlying context state. Repeating the instruction into an already-full window does not fix the compression and the same failure recurs. The credited response addresses context state -- restart, summarise, or persist -- and, better, prevents recurrence by segmenting the task with interim saves.
Worked example
An analyst gives Claude detailed formatting and scope instructions at the start of a demanding three-hour session. Two hours in, Claude's output no longer respects those instructions. The analyst simply re-pastes the same instructions into the current conversation, and they hold for a few turns before slipping again. Diagnose the situation and prescribe a better approach.
The re-pasting is treating a context-state problem as a compliance problem, which is exactly the trap. Start with the diagnosis. The instructions were respected at the start and stopped being respected two hours in, in the same session. That timeline shows the model understood them -- it followed them early -- so the cause is not the model changing its mind or disregarding them. Over three hours the context window filled, and the earliest content, including those detailed instructions, was compressed and lost force. The correct diagnosis is context compression.
That diagnosis explains why re-pasting only holds for a few turns: it briefly reintroduces the instructions into active context, but the window is still full and near its limit, so the fresh copy is soon compressed again and the failure recurs. Repeating the instruction in place does nothing about the filled window, which is the underlying cause. It is a symptom patch that guarantees the loop.
The better approach addresses context state and, ideally, prevents the problem. Since the thread's work is presumably still coherent, summarise the decisions, scope, and in-progress work -- and crucially the formatting and scope instructions -- then restart into a fresh conversation with that summary, so the instructions are back in an uncompressed window. If those instructions should govern all future sessions, persist them to Memory or the knowledge base. Best of all, redesign the work: split the three-hour task into segments, saving interim results to the knowledge base at each boundary, so no single session runs long enough to compress critically. Planning those boundaries in advance is far stronger than extending one marathon session and re-pasting instructions each time the window swallows them.
Common misreadings to avoid
Misconception
When early instructions stop holding late in a session, Claude has changed its mind about them.
What's actually true
Misconception
Re-pasting the dropped instruction into the same conversation fixes the problem.
What's actually true
How this shows up on the exam
Questions describe a long session where early instructions fade and ask for the diagnosis and fix, with distractors that blame the model or repeat the instruction in place. Use the timeline -- followed early, dropped late -- to diagnose compression, then prescribe a context-state response and, for full credit, the segment-and-save prevention strategy. The reliable answer never treats it as a compliance problem to be re-pasted away.
This capstone knowledge point draws together the finite context budget, recognising degradation, the three responses, and choosing between restart and summarise.
Two hours into a three-hour session, Claude stops respecting detailed instructions it followed at the start. The analyst re-pastes the same instructions, which hold briefly then slip again. What is the correct diagnosis and best response?
People also ask
Why do early instructions stop holding in a long Claude session?
Is Claude ignoring instructions or is it context compression?
How do I prevent long-session context failures?
Watch and learn
Official Anthropic Academy lessons first, then hand-picked walkthroughs. Videos load only when you press play.
No videos curated for this concept yet
We are still curating the best official and community videos for this topic.
Official prep for this domain
Anthropic's own free prep module for this part of the syllabus, on the official prep course. Free with an Anthropic Academy sign-in.
References & primary sources
Master this concept with Archie
Practice it inside an adaptive study session. Archie, your Socratic AI tutor, tracks your mastery with Bayesian Knowledge Tracing and schedules the perfect next review.