Don't stop here
Hand-picked guides our readers explore right after this one.
Expert guide to Claude prompts with XML tags, artifacts, and complex reasoning
Read the guideMaster ChatGPT with advanced prompting techniques, mega-prompts, and proven frameworks
Read the guideCreate viral social media content with AI prompts
Read the guideThis is the failure people describe as 'Claude got dumber', and it usually is not the model changing. It is context. Claude re-reads the entire conversation on every turn, so as a thread grows, the instructions you set at the top compete with thousands of words of intervening discussion, and the practical weight of those early rules drops. On paid plans with automatic context management enabled, long threads are summarized behind the scenes so the conversation can continue past the window, which is genuinely useful but has a real cost: the summary keeps the gist and drops the specifics, so a constraint you stated precisely in message three becomes a vague paraphrase by message eighty. Nothing warns you when this happens. You find out when Claude confidently breaks a rule it followed perfectly an hour earlier. The fix is not a setting, it is a working habit: keep threads scoped, restate the contract that matters, and hand off deliberately to a fresh chat instead of letting one thread run forever.
Claude breaks formatting or style rules it followed earlier in the same chat
It re-asks for information you already provided
Answers get shorter, more generic, or repeat earlier replies
Replies slow down noticeably as the thread grows
Claude references an outdated version of a document or decision
A 'conversation is too long' notice appears and you cannot send more
Every message you send includes the entire prior conversation. As it grows, early instructions occupy a smaller share of attention and compete with everything since. Degradation is gradual, not a cliff, which is why it feels like the model changed.
On paid plans with automatic context handling active, older parts of a long conversation are compressed so the thread can continue. The summary preserves the general thread and loses exact wording, edge-case rules, and numbers. There is no notification when it happens.
A large document dropped into the chat consumes a big share of the available context permanently, for every subsequent turn. Two or three long attachments can leave very little room for the actual back and forth.
Mixing a code review, a marketing email, and a research question into one conversation forces Claude to hold three unrelated contexts. Relevance drops for all three, and instructions from one task bleed into another.
A rule mentioned in passing in the second message has far less staying power than one restated as an explicit contract. Without reinforcement, casual early instructions are the first thing to fade.
When to try: Any time a long thread starts drifting
Before a turn that matters, paste a short block: the goal, the hard constraints, the format required, and anything Claude must never do. Five lines is enough. Recency is the most reliable lever you have, and this single habit prevents most instruction drift.
When to try: When the thread is long or quality has visibly dropped
Ask Claude: 'Write a handoff brief for a new conversation: current goal, decisions made and why, constraints, open questions, and the exact current state of the work.' Start a new chat, paste that brief, and continue. You get a clean window with the substance preserved.
When to try: For ongoing work you return to repeatedly
Put persistent instructions and reference documents in a Claude Project rather than in the conversation. Project knowledge and custom instructions apply to every chat in the project, so they do not decay as any single thread grows.
When to try: As a default working habit
Start a separate conversation for each distinct piece of work. Short focused threads outperform one long mixed thread on every axis: accuracy, speed, and instruction adherence. It also makes handoffs trivial because each thread has one subject.
When to try: For any multi-session document or codebase work
Maintain the working document (the draft, the spec, the code) outside the conversation and paste the current version when you need work done on it. Then the freshest copy is always in recent context, and no summary can quietly revert you to an older version.
When to try: When you suspect drift but are not sure
Send: 'Before answering, list the constraints you are currently working under.' If the list is wrong or incomplete, you have caught the drift before it costs you an output. This is the cheapest diagnostic available and takes one turn.
When to try: Before uploading large files
Paste the relevant section rather than the whole document, and remove attachments once you are finished with them by starting a new chat. Every token spent on material you are no longer using is room taken from the discussion that matters.
When to try: Claude Code sessions, at each natural stopping point
If you are working in Claude Code, run /compact deliberately when you finish a task rather than letting compaction trigger mid-problem. Compacting at a clean boundary preserves the decisions that matter and discards the exploration that does not.
Start a new chat for each distinct task rather than growing one long thread
Keep standing rules in a Project, not in the conversation body
Restate hard constraints in a short block before important turns
Ask for a handoff brief while the thread is still working well, not after it degrades
This is expected behavior for long conversations rather than a bug, so support cannot fix it. Contact Anthropic support through claude.ai if quality drops sharply in short, fresh conversations too, if you see errors rather than degradation, or if a Project's instructions are demonstrably not being applied in new chats within that Project. Include example conversation links and timestamps.
Claude re-reads the whole conversation each turn, so an instruction from early on competes with everything said since and carries less weight over time. On paid plans, automatic context management also summarizes older messages to keep the thread going, and summaries preserve the gist while dropping exact wording. Restating the constraint is what restores adherence.
Not in a way you will notice. Automatic context handling compresses earlier parts of a long thread so it can continue past the context limit, and the conversation carries on smoothly. That is exactly why the failure is confusing: nothing visibly breaks, Claude just starts violating rules it followed before.
In the overwhelming majority of reports the thread is the cause. The test takes one minute: open a brand new chat, give the same task with the same instructions, and compare. If the fresh chat performs well, the model is fine and your context was the problem.
Ask Claude to write a handoff brief covering the goal, decisions made and why, constraints, open questions, and the current state of the work. Open a new chat, paste it, and continue. You keep the substance and reset the window, which is far more effective than fighting a degraded thread.
Yes. A long document occupies part of the context window for every turn afterwards, leaving less room for your discussion. Paste only the relevant sections, and start a fresh chat once you are done with a file rather than carrying it through the rest of the work.
Product behavior and limits can change. These primary sources were used to verify this guide.