Claude Certified Architect Professional: Complete Course

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.

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.

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.

Choose models by task complexity, volume, latency, and cost rather than defaulting to the largest one.

Derive acceptable accuracy, latency, and cost trade-offs from SLAs for interactive and offline workloads.

Design system prompts and templates as maintained system components that separate stable policy from dynamic user content.

Manage the context window as a limited resource using prioritization, summarization, and retrieval instead of sending everything.

Cut cost and latency while improving maintainability with prompt caching, modular prompt components, and reusable Skills.

Mark a 1,900-token policy with cache_control and watch usage switch from cache write to cache read.

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.

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.

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.

Know when each prompting strategy adds value and when it only adds cost and complexity.

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.

Keep trusted instructions separate from user input, retrieved content, and tool results so external text cannot redefine system behavior.

An order note tries to force a 500 refund; the prompt labels tool data as data and the code gate limits the money.

Load context incrementally through lightweight starting context and query-driven retrieval to save tokens and improve relevance.

The whole document in every prompt or a table of contents with a read tool: tokens and accuracy on two corpora.

Require evidence and source attribution, and combine schema and semantic validation to catch unsupported claims.

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.

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.

Follow the full RAG pipeline from source documents, ingestion, and indexing to retrieval, context assembly, and cited answers.

Choose fixed, structural, or semantic chunking, and handle tables and long documents without losing meaning.

Cut the return policy two ways, fixed-size and by section, and measure recall@3 on twelve real questions.

Match keyword, semantic, metadata, and hybrid retrieval to your data shape and query patterns, balancing precision and recall.

Send retrieved sections as search results with citations; the answer names its source or says the policy does not cover it.

Trace failures to wrong, missing, or stale chunks before concluding that the model is at fault.

A confident wrong answer after a policy change: print what retrieval returned, find the stale index, rebuild it.

Select an integration mechanism by weighing coupling, reusability, control, and interoperability.

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

Spot identity and permission gaps by separating who a caller is from what that caller is allowed to do.

Reduce attack surface and tool-selection errors by removing unnecessary capabilities and applying least privilege.

Cut an agent from six tools to a role of three, measure the token cost, and check identity from the session inside the tool.

Make model calls, tool calls, retrieval, and errors traceable end to end using correlation IDs and distributed traces.

Decide when a coordinator with specialized agents helps, and account for shared state, failure propagation, and coordination overhead.

Build an agent with the Claude Agent SDK in Python: you write the task, the allowed tools and a turn limit, and the SDK runs the loop for you. Then add a PreToolUse hook that blocks rm and .env access, and watch the agent run the safe command while the delete is denied.

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

Break large goals into capabilities by separating independent from dependent work and planning validation and recomposition.

Decide where extra retrieval, model calls, validation passes, or parallelism are worth their added delay within a latency budget.

Design structured handoffs between stages, agents, and humans that preserve state, evidence, and recommended actions.

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.

Define what good means across accuracy, latency, cost, safety, and business metrics before you start optimizing.

Assemble evaluation data covering common, edge, failure, and high-risk cases that mirror real production traffic.

Combine deterministic checks, model-based grading, and human review according to criteria, cost, and scale.

Run the same twelve cases through two models and choose by correctness, median latency and cost per thousand requests.

Compare a baseline and a variant for prompt, model, or architecture changes and make evidence-based rollout decisions.

Find the earliest broken stage in the pipeline and fix the root cause instead of changing settings at random.

Reduce waste from repeated or irrelevant context using caching, pruning, and retrieval without hurting answer quality.

Speed up responses with parallel calls, smaller context, and faster models while protecting critical validation steps.

Replace create with messages.stream, print the text as it arrives, and read stop_reason and usage from the final message.

Track logs, metrics, traces, and model and prompt versions to detect regressions and trends in production.

Wrap the client once and log every call of a multi-agent run with a trace ID; read p50, p95, cost and the slowest step.

Systematically identify risks such as hallucination, prompt injection, and data leakage, and rate them by likelihood and severity.

Combine prompt controls, tool restrictions, validation, deterministic policies, and monitoring because no single guardrail is enough.

Decide where human review belongs, for high-impact, ambiguous, or low-confidence cases, without creating unnecessary reviewer workload.

Refunds above the limit go to a review queue; the reviewer decides, the code acts, and Claude only writes the update.

See how data minimization, purpose limitation, retention, and deletion requirements shape system design.

Replace emails, card and phone numbers with placeholders before the request; keep the key in the environment and out of git.

Apply HIPAA-oriented thinking to protected health information, access restrictions, logging, and system boundaries.

Understand how approved environments, audit requirements, and vendor constraints limit architecture choices in government workloads.

Build fairness and transparency into design through representative evaluation, disclosure of automation, and monitoring across user groups.

Ask the right questions about goals, users, data, risks, and success criteria before choosing any technology.

Present decisions, alternatives, risks, costs, and SLA impact in terms that technical and executive audiences both understand.

Negotiate conflicting priorities and realistic SLAs, and document the trade-offs everyone has agreed to.

Write documentation covering boundaries, data flows, security, and failure handling that engineers can actually build from.

Walk the early lifecycle from requirements, architecture, and prototype through evaluation to engineering handoff.

Own the solution after release through monitoring, incident learning, evaluation refresh, and revisiting architectural assumptions.

Set up Claude Code for teams with shared instructions and reusable workflows for exploration, refactoring, testing, and review.

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.

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.

A PreToolUse hook in .claude/settings.json exits with 2 and stops rm and .env access in a headless run.

Use logs, traces, and reproduction to find root causes of production failures and feed the lessons back into architecture and evaluation.

Make requests fail on purpose: a wrong key, a removed parameter, a 50 ms timeout; learn which errors to retry and which to fix.