Troubleshooting and Optimization·Task 7.1·Bloom: understand·Difficulty 2/5·8 min read·Updated 2026-07-14

The Cheapest-Fix-First Diagnostic Sequence

Identify, diagnose, and resolve issues with underperforming prompts or poor outputs

SUBy Solomon UdohReviewed by Solomon UdohAI-assisted · human-reviewed
In short
The diagnostic sequence is an ordered checklist run before concluding a task is impossible: re-read the prompt for under-specification, check the conversation length for context overload, check the feature and model, check the configuration for drift, and only then question whether the task fits Claude at all. The order runs from the cheapest check to the most expensive conclusion, so the common, low-cost causes are ruled out before the rare, high-cost one is reached.

Why the order of the checks matters

Knowing the four root causes is not enough on its own; you also need to know what order to check them in. The Claude Certified Associate - Foundations (CCAO-F) exam teaches a specific sequence, and the sequence is not arbitrary. It runs from the cheapest possible check to the most expensive possible conclusion, so that you spend the least effort on the most likely fixes and reserve the costly, attempt-ending judgement for last.

The discipline this instils is resisting the natural urge to jump ahead. Most people, faced with a bad output, leap to one of two expensive moves: "switch to the most capable model" or "this task is impossible." Both are near the end of the sequence, and both are usually unnecessary. Running the checks in order almost always lands on a cheap fix before you ever reach them, which is exactly the point.

The diagnostic sequence
An ordered checklist run before concluding a task cannot be done: (1) re-read the prompt against what it should specify, (2) check the conversation length for context overload, (3) check the feature and model, (4) check the configuration for drift, and (5) only then question whether the task fits Claude at all. Ordered cheapest-fix-first.

From cheapest check to most expensive conclusion

Step one is re-reading the prompt. It costs seconds and resolves the single most common failure, under-specification, so nothing else earns its place ahead of it. You read the prompt against what it should carry, context, constraints, format, and add whatever is missing. If that fixes it, you have spent almost nothing.

Step two is checking conversation length. If the prompt was fine, the next cheapest cause is context overload: a session grown long enough that early content was compressed. The remedy, a restart from a summary, costs a little more effort than a prompt edit, which is why it sits second. Step three checks the feature and model: is this arithmetic that belongs in code execution, or a deep task handed to a speed-tier model? Switching features or model is a bigger change, so it comes after the two cheaper checks.

Step four checks the configuration, the standing instructions, knowledge sources, and Skills, for drift. This is more involved because it means auditing the setup rather than the immediate interaction. Step five, and only step five, questions whether the task is a fit for Claude at all. This is last because it is the most expensive conclusion: it ends the attempt entirely. You reach it only after the four cheaper causes have been ruled out, which is why recognizing a genuine task-fit mismatch is treated as a separate, harder skill.

The diagnostic sequence, cheapest fix first
Loading diagram...
Each step costs a little more than the one before it, so the most common, cheapest causes are ruled out before the rarest, most expensive conclusion is reached.

What the CCAO-F exam trips candidates on

The first trap is jumping straight to "switch to the most capable model" before checking whether the prompt was simply under-specified. Upgrading the model is an appealing move because it feels decisive, but it is step three at the earliest, and it does nothing for an under-specified prompt. The exam rewards the candidate who re-reads the prompt first and finds the missing constraint that a bigger model would not have supplied.

The second trap is concluding a task is impossible without running the cheaper checks. Declaring "Claude can't do this" ends the attempt, which is exactly why the sequence puts it last. A scenario that seems to invite that conclusion is usually testing whether you will run the sequence anyway. In most cases a cheap fix exists, and even when the task genuinely needs reshaping, the credited answer is one that reached that verdict by ruling out the cheaper causes first, not by guessing.

Worked example

A user is frustrated: 'I asked Claude for a detailed competitive analysis and it keeps coming back shallow. I'm going to give up and say it can't do deep analysis.' Walk the sequence and show where the real fix likely is.

Giving up is step five, and the user has jumped to it without running steps one through four. The sequence exists precisely to prevent that leap.

Step one, re-read the prompt: does it actually specify what "detailed" means, which competitors, which dimensions, what depth? If not, add those, because under-specification is the cheapest and most common cause. Step two, check length: is this a long session where an earlier good answer degraded? If it is a fresh chat, overload is not the cause. Step three, check the feature and model: which model tier is selected? If a fast, lightweight tier was chosen to save time, that is the likely culprit for shallow analysis, and switching to a more capable tier is the fix, not more prompt detail.

In this case, step three usually resolves it: shallow analysis on a task that needs depth, produced by a speed-oriented tier, is a wrong-model-tier problem. The point of the walk-through is that the user was about to conclude "impossible" when a cheaper cause, a model tier chosen for speed, was sitting unexamined at step three. Running the sequence in order turns a dead end into a one-setting fix.

Common misreadings to avoid

Misconception

If the output is disappointing, upgrading to the most capable model is a sensible first move.

What's actually true

Switching models is step three at the earliest and does nothing for an under-specified prompt, which is the most common cause. Re-read the prompt first, since it costs seconds and resolves most failures.

Misconception

Once you have tried a couple of things, it is reasonable to conclude the task is impossible.

What's actually true

Concluding a task is impossible is the last and most expensive step because it ends the attempt. Reach it only after running all four cheaper checks in order; jumping to it early usually skips the cheap fix that would have worked.

How this shows up on the exam

Domain 7 questions ask what to do before concluding Claude cannot do a task, and the credited answer is running the diagnostic sequence rather than any single leap. Watch for options that skip to "switch to the most capable model" or "abandon the task", they are the tempting-but-premature moves the sequence is designed to defer.

This knowledge point builds on the four root-cause patterns and pairs with reading symptom timing to identify the cause, which tells you which step is likely to pay off. It feeds into matching scenarios to the correct diagnosis and fix, where timing and sequence combine, and it sets up recognizing a genuine task-fit mismatch, the rare step-five case. Run the sequence automatically and you replace both bad defaults with a decision you can explain.

Check your understanding

An output disappoints and a teammate wants to know what to do before concluding Claude cannot handle the task. Which response best reflects the diagnostic sequence?

People also ask

What should I check before deciding Claude cannot do a task?
Run the sequence in order: prompt, context length, feature and model, configuration, then task fit. Concluding impossibility first is the expensive mistake the ordering is built to prevent.
In what order should I troubleshoot a bad Claude output?
Cheapest check first: re-read the prompt, check context length, check the feature and model, check the configuration, and question task fit last. Re-reading the prompt costs seconds and resolves the most common failure.
Why check the prompt before switching models?
Under-specification is the most common and cheapest cause, while switching to the most capable model is a costlier move that usually was not needed. Ruling out the cheap cause first avoids paying for a fix the problem never required.

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

Adaptive study

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.

Start studying