Context engineering: How to prevent AI workflows from degrading

You build a skill that produces page optimization briefs and it works. A couple of months later, however, the output is noticeably worse. Maybe the briefs are more vague, or they mention services you no longer offer.

When this happens, we might blame a model update or try to fix our prompts. But if the prompt has worked consistently across models, we need to turn our attention to the context the LLMs use to generate output.

By addressing context issues and creating a system to identify and cull rot, you can improve your Claude outputs.

What is context?

Context is everything an LLM reads while it tries to complete a task. While some of the context is provided via the prompt, that’s not the only context Claude and other AI tools rely on.

In addition to any background you shared in your prompt or attached files, context also includes the skills Claude uses, its memory, project knowledge, whatever a tool returns when it runs, what an earlier stage handed forward, and earlier turns of a long thread.

Often, this material loads without anyone asking for it. You didn’t type it into the prompt or point the prompt at it, so there’s no moment in your process where you’d think to review it. Managing that material on purpose is what people mean by context engineering.

Anthropic’s engineering team calls context “the set of strategies for curating and maintaining the optimal set of tokens (information) during LLM inference.” Unfortunately, it’s easy to do the curating once, when you build the skill, and never get back to the maintenance.

What is context rot?

Context rot is what happens when the material a job reads degrades over time. The workflow stays the same while the work around it changes:

• You add or drop a service, and the skill still describes the old offer
• Your company restructures, or your team changes how it works
• A tool you rely on changes what it returns or how it formats it
• Your style guide gets revised, and the old rules are still in the files the job reads
• New files and skills get added that contradict the ones already there
• You move or rename a file, and the instructions still point to where it used to be

None of these changes reach the workflow on their own. It keeps reading the old material on every run.

Dig deeper: How to build a context-first AI search optimization strategy

6 ways context rots

Context rot shows up in six ways:

• Volume issues produce vague output that skips instructions.
• Competition produces inconsistent output.
• Divergence issues mean the same request results in different answers from one run to the next.
• Staleness leads to inaccuracies.
• Conflict produces inaccuracies.
• Contamination introduces the potential for inaccuracies.

Understanding the symptoms of these different types of context rot can help you identify which context to check first. If the output is more vague than it used to be or skips instructions, check how much material the job was given.

Should the same request give you different answers from run to run, check which tools and templates it could pick between, and whether more than one copy of a file exists.

And if you get the same wrong answer every time, check what the job is treating as true: the dates on your reference files, instructions that disagree with each other, and anything an earlier stage handed forward without a check.

1. Volume issues produce vague output that skips instructions

Issues with volume mean there’s too much material in front of the model at once. The output gets vaguer and starts missing instructions you know are in the file.

Your brief skill pulls the full keyword export for the page, plus three competitor pages in their entirety. The brief comes back with 40 keywords and no priority among them, and it skips the internal linking rule sitting in the skill file. A long thread does the same thing. By the fifth brief in one conversation, the model is also reading the first four.

To fix context rot caused by too much material, run extraction and analysis in separate context windows, and limit what a tool returns before the next step reads it. Start a fresh context window when a thread gets long, and leave out reference material the task doesn’t use.

For our example, this would mean pulling the heading structure and key claims from the competitor pages in one context window and writing the brief from those summaries in another. It would also mean filtering the keyword export to the terms worth considering and starting each brief in its own context window.

2. Competition produces inconsistent output

Competition issues arise when there are too many valid options for the model to choose between. Each one is accurate on its own, but they’ve piled up as you connect more tools and add more templates, and the skill picks a different one on each run.

Say you have both Semrush and Ahrefs connected. One brief pulls keyword difficulty from Semrush and the next from Ahrefs, with different numbers and no note about which was used. If the skill has three brief templates available, the layout changes from one run to the next.

To fix context rot caused by too many valid options, name the tool and template you want in the instructions, and remove options the task no longer uses. For our example, this would mean naming one keyword tool as the source for difficulty scores in the brief skill and deleting the two templates you’ve stopped using.

Dig deeper: How a ‘client brain’ gives AI the context SEO work needs

3. Divergence issues produce inconsistent output

Divergence occurs when material that’s supposed to match drifts apart. You update one file, but copies of it or examples built from it still reflect the old version, and the workflow reads those, too.

When you revise the brief template in the skill, the sample briefs attached to the skill still follow the old format, and so does the copy of the template you pasted into project knowledge. New briefs come back mixing the two layouts.

To fix context rot caused by divergence, keep each piece of material in one place and point everything else to it. When you change a format or rule, update the examples built from it in the same sitting. If you need copies, put a version number or date inside each one.

For our example, this would mean removing the template from project knowledge and replacing the sample briefs with ones in the new format.

4. Staleness leads to inaccuracies

Simply put, staleness is material that was accurate when you wrote it and isn’t now. The output stays confident and specific, and that’s what makes it expensive.

You dropped a service last quarter, but the skill’s service list still includes it. The briefs recommend internal links to a page you’ve since redirected and pitch the old service in the CTA.

To fix context rot caused by stale material, put the date inside each reference file as well as in the filename. Review service lists, competitor sets, ideal customer profile documents, and voice guides on a regular schedule.

For our example, this would mean updating the service list in the skill the same week the service changes, as well as dating the file so it’s easy to see when it was last checked.

Dig deeper: How to build an AI content workflow from the ground up

5. Conflict produces confident inaccuracies

Conflict arises when two things in the context disagree, and nothing in the output tells you which one it followed.

Your skill says briefs should be written as prose so the client’s writers can follow the reasoning. Months ago, you told Claude you prefer bullet-heavy briefs, and that preference is still in its memory. New briefs come back as prose with bulleted sections dropped in, which neither source asked for.

To fix context rot caused by conflicting material, ask Claude where the instruction it followed came from. It can point to the skill file, project knowledge, or memory it drew on, and you can decide which source should win and remove the other. Treat its answer as a lead, and confirm it in the file or by setting names.

When you add a new rule, ask Claude to check it against what’s already in the skill, project knowledge, and memory before you save it. For our example, this would mean asking Claude why the briefs include bulleted sections. Once it points to the preference in memory, you can delete it under Settings > Memory, or update the skill if you’d rather have bullets.

6. Contamination introduces potential inaccuracies

With contamination, a mistake makes it into the context, and every step after that treats it as true. It might be a hallucinated stat in a research summary, a wrong detail saved to Claude’s memory, or an early draft that becomes the reference for the next one.

A research stage turns up a stat about how many searches for the client’s service are local, and nobody checks it. The brief uses it to justify a local landing page, and the draft written from the brief repeats it in the intro. By the time the faulty stat reaches the client, it’s been repeated enough to look established.

Fact-checking decides whether the stat spreads, and it’s also the stage where people hand over too much information. A checker that has the brief’s rationale in front of it knows why you want the claim to be true, and it’s more likely to find a source that backs something adjacent.

To fix context rot caused by contamination, verify a stage’s output before the next stage reads it, and run the fact-check in a fresh context window that contains only the claims and their sources. This issue is the one to put a hard gate on, because contamination spreads through everything downstream.

For our example, this would mean checking the local search stat against its source before the brief uses it, in a context window that doesn’t include the brief’s rationale.

Dig deeper: 7 feedback loops for self-improving AI content workflows

How to find and fix context rot

Pick the workflow you run most often, like the brief skill from our example, and run it once. Then check what it read.

In Claude chat and Cowork, each step Claude takes shows up as a collapsed line in the conversation, like a file it opened, a skill it loaded, or a tool it called. Click a line to expand it and see what came back.

When using Claude Code, run /context for a breakdown of everything loaded into the context window, including memory files, and /memory to open those files. Memory and project instructions may not appear as a step, so ask Claude to list anything it’s drawing on that you can’t see. Write down what the job actually needs and compare the two lists.

Next, identify where that context is called upon. For anything that shouldn’t be there or is out of date, check where Claude pulled it from:

The comparison only catches material the job doesn’t need. If the output is still off after you’ve trimmed, go back to the symptom you started with and run the checks that match it.

Set a recurring reminder to review your skills, project knowledge, connected folders, and memory every quarter, and anything describing how an AI platform behaves every month.

In Cowork, you can make the reminder a scheduled task that asks Claude to list reference files that haven’t been updated in 90 days, so the review starts with a list instead of a blank page.

As you make the edits, change one thing at a time, rerun the job, and compare it against the run before. If you change several at once, you’ll see whether the output improved but not which type of context was steering it.

To get the best outputs, we all need to be context engineers. Make context engineering part of your routine to continue to get the most from your favorite AI tool.

Dig deeper: 6 content audit workflows to build in Claude