How to Answer CCA-F Scenario Questions

Summary:

1. CCA-F scenario questions test architectural judgment, so the skill that passes them is elimination, not recall.
2. Every wrong answer runs one of seven named traps you can learn to spot cold.
3. Work each question by covering the options, reading the stem, and deciding before you look.
4. You walk away with a repeatable elimination drill and a copy-paste seven-trap checklist.

Claude Certified Architect scenario questions don’t hand you a definition to recall. They hand you a broken production system and four plausible fixes, then ask which one a good architect would actually ship. Three of the four are traps. That is the whole game, and it is why heavy Claude users still fail the exam: they studied it like a recall test, and it isn’t one.

What does a CCA-F scenario question actually test?

It tests whether you pick the calibrated fix over three reasonable-looking wrong ones. Every item has four parts: a situation (a concrete production system), a symptom (what’s failing, described by effect, never named as the cause), a question (the decision), and four options (one architect’s choice plus three plausible distractors).

Cover the options and read the stem alone:

SITUATION: A support agent resolves ~85% of contacts on first contact.
SYMPTOM:   It occasionally issues refunds above the $500 ceiling.
CONTROL:   One line in the system prompt: "Never process refunds above $500."
QUESTION:  What should the architect do?

If you can answer that from the situation before you read a single option, the item is well built. If you can’t, the stem is under-specified and it’s rewarding test-wiseness instead of reasoning. Read the situation, decide, then check. That is the rep.

What are the seven traps every wrong answer runs?

Across hundreds of exam-realistic items, the wrong options are not random. They fall into seven recurring shapes. Name the shape and you can eliminate the option without knowing the perfect fix.

1. Constrain, don’t add. Wrong answers pile on more: another subagent, a bigger window, more tools, a higher max_tokens. When the fix is more, it’s almost always the trap.
2. Prompts suggest, systems enforce. When a rule has to hold every time (money, compliance, a limit), “make the prompt clearer or louder” is bait. Must-happen goes in code.
3. Fix the earliest layer. Most wrong answers are real fixes applied too late. Find where the failure originates, not the last visible symptom.
4. Match the fix to the failure. Vague rule wants explicit criteria; inconsistent output wants few-shot; invalid JSON wants a schema. The trap is the right technique aimed at the wrong failure.
5. Escalate on policy, not vibes. Escalate to a human on a policy or risk trigger, never because the model “feels unsure.” Any option that routes on model sentiment is the trap.
6. Never fine-tune, never tell it to be more careful. “Fine-tune the model” and “add an instruction to make no mistakes” are almost always wearing a disguise, and almost always wrong.
7. The most aggressive option is the trap. Gate everything, hard-cap everything, spawn fifty agents to be safe. The calibrated middle usually wins.

Keep this scan on your desk and run it on any option you’re tempted by:

THE SEVEN-TRAP SCAN (run on every option that looks right)
1. Constrain, don't add          -> does it answer the problem with MORE? (agent, window, tools)
2. Prompts suggest, systems enforce -> is a must-hold rule living in a prompt, not code?
3. Fix the earliest layer        -> is it patching a late symptom, not the origin?
4. Match the fix to the failure  -> right technique aimed at the wrong failure mode?
5. Escalate on policy, not vibes -> does it route on the model's "confidence"?
6. Never fine-tune / be careful  -> is the fix "fine-tune" or "tell it to try harder"?
7. Most aggressive is the trap   -> is it the loudest, gate-everything option?

The exam is not an even five-way split, so your drilling shouldn’t be either. Weight it to where the points live: Agentic Architecture and Orchestration 27%, Claude Code Configuration and Workflows 20%, Prompt Engineering and Structured Output 20%, Tool Design and MCP Integration 18%, Context Management and Reliability 15%. Every wrong answer in a good bank runs one of the seven traps above, tagged to one of those five domains.

How do you eliminate three of four options?

Take the refund question. The four options are:

• A. Rewrite the prompt line more forcefully, in capitals, with three refusal examples.
• B. Add a deterministic pre-execution check that rejects any refund with amount > 500 before it runs.
• C. Lower the model’s temperature so it follows the prompt more reliably.
• D. Route every refund, of any size, through a human reviewer.

Run the scan and three fall:

• A is trap #2. A prompt instruction is probabilistic. Capitals and examples make the leak rarer, not impossible, and a financial rule cannot be “rare.”
• C is trap #6 in a quieter costume. Temperature changes how the model samples tokens. It cannot bound a dollar amount. A $900 refund at temperature zero is still a $900 refund.
• D is trap #7, the most aggressive option. Gating every refund destroys the 85% first-contact value the agent exists for, and the rule only needs to fire above $500.

That leaves B, and it’s right because a hard rule with a financial consequence has to be enforced, not requested, at the earliest enforceable layer:

# The architect's choice: a deterministic gate, not a stronger prompt.
# Runs BEFORE the refund tool executes, so no prompt drift can leak past it.
def check_refund(amount: float) -> None:
    if amount > 500:
        raise PermissionError("Refund exceeds $500 ceiling")  # blocks the call

In Claude Code you wire that same gate as a PreToolUse hook, so the check fires deterministically on every refund call regardless of what the model decides:

{ "hooks": { "PreToolUse": [ { "matcher": "issue_refund",
  "hooks": [ { "type": "command", "command": "check-refund-limit.sh" } ] } ] } }

Notice traps #1 and #7 are the same instinct the people who built Claude warn against:

When building applications with LLMs, we recommend finding the simplest solution possible, and only increasing complexity when needed. This might mean not building agentic systems at all. Agentic systems often trade latency and cost for better task performance, and you should consider when this tradeoff makes sense. Anthropic, Building effective agents

The exam turns that guidance into an answer key. The option that adds an agent or gates everything is the one Anthropic is telling you not to reach for.

What broke when candidates studied the wrong way?

The failure mode is studying the exam like recall. It shows up as a brutal gap between practice and reality. Real passer arcs read the same: 766 on a first practice test, climbing to about 780, then roughly 950 on the official practice exam two days out, then 843 on the real thing. Another candidate scored about 950 in practice and 843 live. Another went 980 to 744.

The bank that lulls you into “I’m at 95%” is exactly the one that fails you, because it tests recall while the exam tests judgment. The fix is not more questions. It’s reading every explanation, including for the items you got right, and logging the trap you fell for, not just the question you missed. Half the value hides in the questions you got right for the wrong reason.

What should you actually do?

• If two options both look right → find the constraint buried in the stem and let it break the tie.
• If an option’s fix is “more” (another agent, a bigger window, more tools) → suspect trap #1 and look for the smaller fix.
• If a must-hold rule is enforced by a prompt → it’s trap #2, and the answer enforces it in code.
• If one option gates everything or fine-tunes the model → it’s trap #7 or #6, so eliminate it first and choose between what’s left.

The bottom line

• The exam grades elimination. Learn the seven traps and you answer from the stem, not from the options.
• Must-happen goes in code; should-happen goes in the prompt. That one rule settles a shocking share of items.
• A 950 on a recall-shaped bank is not a 950 on the real exam. Drill judgment, or you’re drilling the wrong muscle.