Claude Certified Developer – Foundations Practice Test

How to Study for the Claude Certified Developer Exam

Build something real against the Messages API before you sit the exam — most integration questions test facts you internalize in an afternoon of coding: model, max_tokens, and messages are the required parameters; the first message must be role "user"; the API is stateless so you resend the whole conversation; stream: true delivers content_block_delta events for perceived-latency wins; images ride in content blocks, not a separate endpoint; thinking budget_tokens must be smaller than max_tokens. Prompt caching is exact-prefix matching — a timestamp at the top of your system prompt silently kills every cache hit, and adding a tool invalidates the whole cache because tools render before system and messages.

For agents, internalize Anthropic's "Building Effective Agents": workflows (predefined code paths) for fixed, predictable steps; agents (model-directed loops) only when the path can't be known in advance; and always start with the simplest thing that works. Security questions reward the same instincts as classic appsec: treat model output and retrieved content as untrusted input, delimit user content so injected "ignore previous instructions" text stays data, scope tools to least privilege, and use hooks — not prompt rules — when a guarantee is required. For Claude Code, know the config surfaces (CLAUDE.md at repo root for shared conventions, settings.local.json for personal permissions, -p --output-format json for CI) and that subagents isolate noisy searches in their own context. Then take our timed 53-question mock to rehearse the real format.

Tool-use mechanics deserve their own study session, because the questions here are precise and the details are easy to half-remember. Internalize the shape of the loop: you send the conversation plus your tool definitions, the model may answer with one or more tool-use blocks, you execute them, and you send every result back — each carrying the id of the call it answers — in a single user message, not spread across several. Splitting them or dropping one breaks the pairing the model relies on. A tool that fails is still a result: return it marked as an error with a message the model can act on, rather than omitting it or raising past it. Append the assistant's whole content back into the history rather than just its text, so the tool-use blocks survive into the next turn. And treat the tool definition as the interface the model actually programs against — the description and the parameter descriptions are what determine whether it calls the right tool with the right arguments, so an under-described tool is a correctness problem, not a documentation nicety.

Round out your preparation with the operational half of the job: cost, latency, and knowing whether the thing works. Caching rewards a specific discipline — put the stable material first and the volatile material last, because the cache matches on a prefix and anything that changes early invalidates everything after it. That single rule explains most cache misses in practice, including the classic self-inflicted one where a timestamp or a per-request identifier sits near the top of the prompt and quietly defeats the whole thing. Verify rather than assume: the usage figures on each response tell you what was written to cache and what was read from it. For work that is not latency-sensitive, batch processing trades immediacy for a lower rate, and the detail worth remembering is that results are matched by the identifier you assigned to each request rather than by their position, since they need not come back in order. Finally, learn the stop reasons and branch on them — a turn that ended because it hit the output limit, because it wants a tool, or because it was declined are three different situations, and code that reads the first content block without checking will eventually be wrong.