10 CCA Exam Anti-Patterns the CCA-F Repeatedly Punishes

The CCA-F exam is built from scenarios in which one or more answer options is a recognisable architecture anti-pattern: enforcing a hard rule with prompt text alone, returning the same error for every failure, giving one agent every tool, running an agentic loop with no stop condition, or spawning sub-agents without passing them the context they need. Learn to spot these ten and most questions collapse from four plausible options to two.

Each anti-pattern below links to the study article that explains the fix in detail. Domain numbering follows our study guide (D1 Agentic Architecture, D2 Tool Design & MCP, D3 Claude Code, D4 Prompt Engineering, D5 Context Management).

Why does the exam keep testing anti-patterns?

Because the exam is scenario-based and asks for the least bad design under stated constraints, the question writers need wrong options that look reasonable. The easiest way to write a reasonable-looking wrong option is to describe something teams actually do: add a sentence to the system prompt, retry harder, give the agent more tools, make the context window bigger. Each of those is fine in some situations and wrong in the one the scenario describes. The skill being tested is matching the mechanism to the guarantee required.

Enforcement anti-patterns

1. Enforcing a hard rule with a prompt instead of a hook. The scenario says an action must never happen (deleting a production table, emailing a customer without approval, running a payment twice). The wrong option adds “NEVER do X” to the system prompt. The model will still do X some fraction of the time; hooks and permission checks will not. Study: The Model Will Override Your Instructions 4-15% of the Time and Select by Consequence AND Verifiability. Domain: D1.

2. Enforcing output structure with a prompt instead of a schema. “Respond only with valid JSON matching this shape” gets you mostly-valid JSON. tool_use with an input_schema gets you structurally valid output every time; semantic validation still has to follow. Study: tool_use Eliminates Structural Errors. Semantic Errors Remain.. Domain: D4.

Tool and error-handling anti-patterns

3. Uniform error messages. Every failure returns “operation failed”, so the agent cannot tell a permission error from a timeout and burns five retries on something that will never succeed. The fix is isError plus a classified error type. Study: Uniform Error Anti-Pattern and Error Type Classification. Domain: D2.

4. Giving an agent every tool. Selection accuracy falls as the tool list grows, and a coordinator with database-write tools it never needs is both less accurate and less safe. Each agent gets only its role’s tools. Study: The Tool Count Curve and Least Privilege: Each Agent Gets Only Its Role’s Tools. Domain: D2.

5. Generic error context in orchestration. A sub-agent or tool reports “database error” upward with nothing else, and the orchestrator retries a resource that has been decommissioned. Structured error context (what failed, whether it is retryable, what was attempted) lets the caller decide. Study: Generic Error Anti-Pattern and Structured Error Context. Domain: D5.

6. Reporting an access failure as a valid empty result. A search times out and the report says “no studies exist”; a database is down and the tool says “order not found”. Failure and absence must be distinguishable in the result. Study: Access Failure vs Valid Empty and its D2 counterpart Your Order Doesn’t Exist, But It Does. Domain: D2 and D5.

Orchestration anti-patterns

7. Unbounded agentic loops. The loop keeps calling the model until it “finishes”, with no iteration cap, no cost cap, and no check on stop_reason. The correct loop is driven by stop_reason and has explicit termination and budget conditions. Study: stop_reason Is the Only Loop Control That Matters and Three Anti-Patterns That Break Agentic Loops. Domain: D1.

8. Hardcoded decision trees where model-driven routing fits. The scenario has open-ended user requests, and the wrong option builds an if/else classifier in front of the model. When the routing depends on understanding language, let the model route (with well-described tools); reserve fixed logic for genuinely fixed pipelines. Study: Model-Driven Decisions vs Hardcoded Decision Trees and Fixed vs Dynamic Decomposition. Domain: D1.

9. No sub-agent context isolation, or the reverse: assuming sub-agents inherit context. Two versions of the same mistake. Either the coordinator dumps its whole conversation into every sub-agent (cost, noise, anchoring), or it assumes the sub-agent already knows the customer ID and passes nothing. Sub-agents start empty; pass structured facts, not transcripts. Study: Sub-Agents See Nothing and Structured Data Preserves Attribution. Domain: D1.

Context anti-patterns

10. Stuffing context instead of managing it. Long session degrades, so the wrong option “uses a model with a bigger window” or appends every tool result verbatim. The fix is structural: filter tool output to needed fields, keep a persistent case-facts block, write findings to a scratchpad, delegate bulk reading to a sub-agent. Study: The U-Shaped Attention Curve, Tool Output Bloat Filtering, and The Scratchpad. Domain: D5.

A close cousin, worth naming even though it makes eleven: routing escalations on model confidence or sentiment. Both are unreliable signals; escalate on explicit human requests, policy gaps, and ambiguous multi-match lookups instead. Study: Confidence Scores Are Unreliable. Domain: D5.

What is the exam really testing with these?

Every anti-pattern above is a case of treating the model as a guarantee when the scenario needs a guarantee from somewhere else: a hook, a schema, a structured error, a scoped tool list, an explicit loop condition, or a context structure. When you read a question, ask “what must be true every time?” and then check which option makes it true mechanically. That single question eliminates most anti-pattern options.

Next step

Test your recognition speed with the free 60-question mock exam; after each wrong answer, name which of the ten patterns the option you chose belongs to. Then work through Domain 1, where five of the ten live, and Domain 5 for the context and error-context patterns.