Claude Certified Architect Foundations: Complete Course

Learn how the hands-on labs work in this course, how to open and run the Jupyter notebook, complete the coding tasks, and follow along with the lesson videos - no local setup or API key required.

Send one request to Claude from Python, read the response object, and see why max_tokens is a ceiling you must check with stop_reason.

See that the API remembers nothing between requests, keep the conversation in a list your code sends every turn, and watch the input tokens grow.

Put a small web server between a chat page and Claude: the browser posts to your server, the server adds the system prompt and history, and only it calls Claude.

Give Claude a role and scope in the system prompt, then enforce a rule that must always hold with a gate in code that runs before any request leaves.

Choose a model family and effort level for each step, use max_tokens as a limit, and check stop_reason before a reply reaches the customer.

Find out why the same question gets different answers. Fix judgment problems with a clear criterion in the prompt and rules that must always hold with code.

Build a six-case test set with expected verdicts, score a prompt in code, find the gap it reveals, and compare two prompts by their scores.

Follow one change through a repository, a branch, commits and a pull request, and understand where code review happens before anything reaches customers.

Understand the CI checks that run on every pull request, such as tests, linters and review bots, and know whether a failed check blocks the merge or only reports.

Make a review bot report only real problems: name what to report and what to skip, define severity with code examples, and pause noisy categories.

Fix uneven output with two to four few-shot examples that show the exact format, explain the reasoning on unclear cases and use contrasting pairs.

Stop empty or made-up values in extraction by adding few-shot examples that show different document layouts and how to read informal wording honestly.

Practise exam decisions on noisy review bots: why "be conservative" fails, and why named categories and severity levels defined with code work.

Practise exam decisions where louder wording fails: show the format with few-shot examples, and pair similar cases with reasoning to cut false positives.

Read JSON fields, types and arrays, and understand how schemas and tool definitions let Claude and the application agree on data and actions.

Define one tool, see Claude stop with tool_use, run the function in your code, send the tool_result back, and get the final answer.

Know when to use tool_choice auto, any or a forced tool on the exam, and how current code uses auto with strict tools or structured outputs instead.

Make Claude fill a JSON schema so the output always parses, and see why a schema-valid value can still be wrong. Exam lane and current product both covered.

Allow null for unknown values, validate the fields in code, and when validation fails send the exact error back to Claude for a bounded retry.

Retry a failed extraction with the original document, the failed output and the exact validation error, and know when a retry cannot help.

Design output fields that expose hidden errors: stated vs calculated totals, a conflict flag for sources that disagree, and patterns behind dismissed findings.

Direct human review with evidence: calibrate field-level confidence on labeled data, check accuracy per document type and field, and keep stratified sampling.

Decide when the Message Batches API fits: work nobody waits for, facts added before submitting, and a submission interval that fits the deadline.

Run a batch without paying twice: test the prompt on a small sample, match results by custom_id, and fix and resubmit only the failed requests.

Learn to make extracted fields safe for other software: a JSON schema for shape, code checks for meaning, nullable fields for missing values, and format rules plus targeted retries.

Learn why tool_choice any or a forced tool makes every extraction produce a tool call, and how to cut human review by measuring accuracy per document type and field, not one average.

Run the checked extraction over a folder of emails, keep a status per record, save the batch as JSON, and route the unclear ones to a person.

Understand the agentic loop: continue while stop_reason is tool_use, finish on end_turn, keep Claude's full response in the history, and let Claude choose each next tool.

See why stopping an agent on Claude's words or a round counter fails, and why stop_reason is the only reliable signal, with the iteration cap kept only as a safety net.

Write the loop that sends the conversation with tools, reads stop_reason, runs every tool_use block, returns the results, and repeats until end_turn.

Learn how Claude picks a tool from its description, and fix misrouting by writing descriptions that state purpose, input, edge cases and when to use the neighboring tool.

When better descriptions are not enough, learn to rename overlapping tools, split a general tool into one tool per job, and remove keyword triggers from the system prompt.

Learn to return structured tool errors with is error, a category and is retryable, so the agent knows whether to retry, fix the input, explain a policy or stop.

Learn to give business errors a customer-safe message and a separate log note, and to keep empty results apart from access failures, so 'nothing found' never hides 'could not look'.

Return not-found as data and real failures as structured errors with a flag, a category, a retryable flag, and separate customer and developer messages.

Understand what MCP servers offer: tools for actions, resources for content catalogs, community servers for standard systems, and better descriptions so the agent picks the right tool.

Expose the tools through an MCP server, register it with Claude Code, and watch Claude Code discover and call them, including a structured refusal.

Understand what the Claude Agent SDK does for you: query runs the agent loop, allowed tools limits what the agent may use, and hooks enforce rules that must always hold.

Learn why a prompt cannot guarantee that a customer is verified before order or refund actions, and how a prerequisite gate in code blocks those calls every time.

Learn how Pre Tool Use hooks block or redirect risky tool calls, like large refunds, and how Post Tool Use hooks turn mixed data formats into one before Claude reads them.

Learn to split a message with several problems into items that share facts, answer them in one reply, and write a structured handoff a human agent can act on at once.

Learn when a support agent should hand a case to a person: an explicit request, an exception, a policy gap or no progress, and how to write these criteria with few-shot examples.

Learn which signals should not trigger escalation: customer anger, a self-reported confidence score, or several matching customers, where the agent asks for another identifier instead.

Learn why repeated summaries lose exact amounts, dates and promises, and how a case-facts block kept outside the summary, with one entry per issue, keeps them correct.

Learn to trim tool results to the fields that matter before they enter the context, and to start long inputs with a key-findings summary so facts are not lost in the middle.

Learn to sort agent failures by layer: put rules that must always hold in code, such as gates and hooks, and fix wrong tool choices in the tool descriptions first.

Decide when a support agent should hand a case to a person, answer business errors without retrying, and keep exact amounts safe in a case-facts block.

One loop with a verification gate, a hook that checks every tool call before it runs, case facts kept in code, and a handoff to a person.

Learn when to use prompt chaining for fixed, known steps, and when to use adaptive decomposition, where the plan changes as the agent discovers what the work really needs.

Understand why every message in a multi-agent system passes through the coordinator, how it picks subagents for each request, and how to brief them with goals and quality criteria.

Find out why a research report misses whole areas, split a topic into parts that cover all of it without overlap, and close gaps with targeted queries.

Start subagents with the Task tool, write clear agent definitions, and run independent subagents in parallel by putting several Task calls in one response.

Give each agent only the four or five tools its role needs, prefer constrained tools, and add one narrow cross-role tool for frequent simple checks.

Learn that a subagent knows only its prompt, and pass findings as structured records that keep each claim tied to its source, date and method.

Split the work between a coordinator and two subagents with their own tools, pass context explicitly, and see what each agent really receives.

Handle a failing subagent: retry temporary errors where they happen, report failures with structured context, and let the final report state its gaps openly.

Keep every claim linked to its source with claim-source mappings, keep sources when synthesis merges claims, and show each kind of content in the format that fits it.

Handle sources that disagree: keep both values with their sources, use dates to tell a real conflict from a trend, and show contested findings in their own section.

Trace research failures back to the coordinator: fix a narrow split, report an unreadable source in four parts, and limit each agent to the tools its role needs.

Fix a report with missing citations and conflicting figures: pass claim-source records, check dates first, and let the coordinator decide how to handle conflicts.

Know which CLAUDE.md level reaches whom, check loaded memory files with /memory, and move team conventions into the project CLAUDE.md.

Split a large CLAUDE.md into focused files in .claude/rules, and use @import so each package loads only the shared standards it needs.

Use a paths field with glob patterns in .claude/rules so a convention loads only when Claude Code works on matching files, wherever they sit.

Decide where a custom slash command or skill should live so the right people get it, and choose between a skill and CLAUDE.md for each workflow.

Control a skill with three frontmatter keys: context: fork for noisy output, allowed-tools to limit what it can do, and argument-hint for the input it needs.

Set up a project for Claude Code: conventions in CLAUDE.md, a path-scoped rule, and a skill with a description and allowed tools, then see them used.

Share team MCP servers in .mcp.json, keep personal ones in ~/.claude.json, and write secrets as environment variable names so no token is committed.

Choose between plan mode and direct execution from what the task already tells you, and plan first when a change touches many files or has several valid approaches.

Learn which built-in tool fits each job: Grep for file contents, Glob for file names, Edit for one unique spot, Read plus Write when no unique anchor exists, and Bash to run tests.

Learn how an agent explores unfamiliar code: find the entry point with Grep, follow imports with Read, and search for every name a wrapper module exports.

Use the Explore subagent to run noisy code discovery in its own context, so the main conversation keeps room for design decisions and edits.

Stop re-describing a change Claude Code keeps misreading: give input and output examples, write tests first, and share exact failures and edge cases.

Let Claude Code interview you before work in an unfamiliar area, send problems that interact in one message, and fix independent problems one at a time.

Decide when to resume a named Claude Code session and tell it which files changed, and when to start fresh with a structured summary because old results are stale.

Fork a Claude Code session to compare two approaches fairly from one shared analysis, and tell a session fork apart from a skill's context: fork setting.

Spot context degradation in long Claude Code explorations, keep key findings in a scratchpad file, and run /compact safely after updating your notes.

Split a long exploration across subagents with focused questions, pass phase summaries into new prompts, and recover from crashes with saved state and a manifest.

Fix a Claude Code setup that works for one developer only: move conventions to the project CLAUDE.md, path-scoped rules, shared commands and forked skills.

Choose plan mode or direct execution from what a task already tells you, and fix repeated mistakes with exact input, expected output and tests.

Help a developer agent explore large legacy code without filling its context, and make bulk changes safely with Glob, Edit, a Read/Write fallback and Bash tests.

Fix an ignored MCP tool by rewriting its description, offer catalogs as resources, and share community servers in .mcp.json with secrets in environment variables.

Understand why the session that wrote code should not review it, and use an independent review instance with fresh context to catch subtle bugs.

Avoid shallow reviews of large changes with per-file passes, an integration pass for data between files, and confidence scores that route findings, not filter them.

Integrate Claude Code into CI/CD pipelines and use independent review to detect issues before deployment.

Give CI runs the context they cannot see: standards and fixtures in CLAUDE.md, existing test files for new tests, and earlier findings to stop repeat comments.

Run Claude Code as a CI reviewer in print mode with JSON output and a schema, read the verdict in a script, and let the exit code decide.

Fix a CI job that hangs, posts unreadable output, repeats itself or duplicates tests, using -p, a JSON schema, earlier findings and a committed CLAUDE.md.

Turn dismissed review comments into data with a detected pattern field, and give large changes a fresh reviewer, per-file passes and confidence-based routing.

Tell apart exam options on agents, tools and context: stop_reason, code over prompts, clear tool descriptions, honest errors, real escalation triggers and case facts.

Tell apart close Claude Code options by asking who needs a setting and when it loads, and what the task says about its size, its context and who is watching.

Spot wrong Domain 4 options that only change volume, size or tone, and pick the ones that give named categories, examples, schemas or a fresh reviewer.

Download the 4-page CCAR-F Quick Reference: the key facts and traps in course order, five diagrams, and a lecture number next to every point.