Building with the Claude API: Foundations to Agents.

You'll walk away with

1. How client.messages.create() works, including system prompts, temperature, streaming, and structured outputs
2. How to build a prompt-evaluation pipeline with model-based and code-based grading on a curated test set
3. Six prompt-engineering techniques: clarity, specificity, XML tags, examples, role, decomposition
4. How tool use works end-to-end: schemas, message blocks, tool results, multi-turn tool calling, fine-grained streaming
5. How RAG composes (chunking, embeddings, BM25, multi-index reranking) and how prompt caching, vision, citations stack on top
6. How MCP exposes tools/resources/prompts, and when to choose workflows (chaining, routing, parallelization) versus full agents

Read these first

Lesson outline

Every lesson from Building with the Claude API with our one-line simplification. The Skilljar course is the source; we summarize.

The course in 7 paragraphs

Building with the Claude API is the spine of the entire Skilljar catalog. Eighty-five lessons, fourteen sections, organized as a strict bottom-up build: messages → system prompts → streaming → structured outputs → evals → prompt engineering → tool use → RAG → features → MCP → agents and workflows. Each section assumes you have the prior. The course is heavy on hands-on Jupyter-notebook exercises and rewards code-along; passive watching loses ~60% of the value. If you can take only one Skilljar course before the exam, take this one, because it is the canonical reference every other course assumes.

The API surface itself collapses to one function and three primitives. The function is client.messages.create(model, max_tokens, messages, ...). The primitives layered on top are system prompt (role and behavior), temperature (0.0 deterministic to 1.0 creative), and streaming (token-by-token via stream=True). The conversation is *your* responsibility; Claude is stateless, you append assistant responses back into the messages list yourself. `max_tokens` is a safety cap, not a target; Claude doesn't try to fill it. Structured outputs come for free if you ask for JSON in the prompt, but for strict schemas the production-quality pattern is to use tool-calling as a structured-output mechanism, which the course transitions to in Section 6.

Evaluation is the gate between a demo and a system, and prompt engineering is what you do once that gate is open. Section 4 (Lessons 16-23) walks the eval workflow in five steps: generate a diverse test dataset (use Claude itself, then hand-curate), run the prompt against each input in parallel with rate-limit handling, grade outputs (model-based for subjective criteria, code-based for mechanical ones), score, iterate. Section 5 (Lessons 24-30) layers prompt engineering on top: be clear and direct (ambiguity is the dominant failure mode), be specific (concrete constraints beat abstract instructions), use XML tags (<document>, <example>, <question>; Claude is trained to attend to them), provide examples (multishot beats explanation), define a role, and decompose multi-step reasoning. The five-step engineering loop (goal → prompt → eval → apply technique → re-eval) is *only* possible if you have the eval pipeline from Section 4 in place; without evals, every prompt change is vibes-based. Pair Lesson 27 (XML tags) with the docs.claude.com prompt-engineering guide; both are required reading for the exam's prompt-engineering domain.

Tool use is the longest section (Lessons 31-43) and the most tested concept on the exam. The mental model: you describe tools to Claude (name, description, JSON input schema), Claude decides when to invoke them, you actually run them, you send the result back via a tool_result block, repeat. The agent loop is just `while stop_reason 'tool_use'==; when stop_reason flips to end_turn, the model is done. Three sub-skills the course emphasizes: writing good tool descriptions (the description is what Claude reads to choose), iterating message *blocks* not message *strings* (responses are arrays of text, tool_use, thinking blocks), and matching tool_use_id` between request and result. Fine-grained tool calling (Lesson 40) streams tool inputs as they're generated; important for progressive UIs but optional for first builds.

RAG is presented as a composition pattern, not a product. Lessons 44-50 walk the full pipeline: chunk documents (semantic boundaries beat naive token splits), embed chunks (vectorize with an embedding model), store in a vector DB, retrieve at query time by cosine similarity, rerank, stuff into the prompt, generate. The production move is multi-index retrieval: combine dense (embeddings, captures meaning) + sparse (BM25, captures exact terms) and rerank. The course's RAG section is video-heavy and short on code, so the actual implementation work happens in Lesson 48; treat the rest as conceptual scaffolding. Pair this section with the Citations and Prompt Caching lessons from Section 8, because production RAG always involves both.

Section 8 (Features of Claude) is where the exam-tested optimization knobs live. Prompt caching (Lessons 55-57) marks a prefix as cache_control and reuses it across calls at ~10% cost; the rules are strict; cache breakpoints must be deterministic, ordered, and exact, and any change above the breakpoint invalidates everything. Extended thinking gives Claude an explicit reasoning budget (thinking={'type': 'enabled', 'budget_tokens': N}) for hard problems. Vision (image and PDF) is a content-block extension; pass image or document blocks alongside text. Citations attach source spans to claims; built-in for document blocks. Code execution and the Files API give Claude a Python sandbox. All five of these are highly testable on the certification and stack with tool use and RAG; learning them together is faster than learning them separately.

MCP and agents close the course. Lessons 60-71 build a working MCP server and client from scratch, with three primitives: tools (actions Claude can take), resources (read-only context Claude can fetch by URI), prompts (reusable templates the server publishes). The MCP Inspector is a dev tool that connects to your server and lets you call everything manually; use it before you wire up any client. The agents section (Lessons 76-83) frames the architectural choice cleanly: workflows for predictable, predefined paths (parallelization, chaining, routing) and agents for paths that depend on what the model finds (loop on tool_use, model decides when done). The course's final claim is that workflows and agents are not opposites; production systems usually mix them, with agents inside specific workflow steps. This is the architect-role conceptual takeaway; the certification's D1 domain hinges on getting it right.

6 takeaways with cross-pillar bridges

How this maps to the CCA-F exam

Domains

D2 Tool Design + Integration · D1 Agentic Architectures · D4 Prompt Engineering · D5 Context + Reliability

Blueprint

18% (D2) + heavy spillover into D1 / D4 / D5

What it advances

The most exam-relevant single course in the catalog. Direct prep for D2 tool design, D1 agentic loops, D4 prompt engineering, and D5 context features (caching, batch, streaming, citations, vision). If you can only take one Skilljar course before the exam, this is it.

3 hand-picked extras

These amplify the Skilljar course beyond what the course itself covers. Each was picked for a specific reason.

Concepts in this course

Where you'll see this in production

Other course mirrors you may want next

8 questions answered

Phrased as the way real students search. Tagged by intent so you can scan to what you actually need.