Claude Certification

You’ve covered every domain. This lesson turns it into a plan, a one-page revision sheet, and tactics for exam day.

🗺️ 6-week study plan (6–8 hours a week)

📋 One-page cheat sheet

LOOP        continue while stop_reason=="tool_use"; stop on "end_turn". Never parse text.
RESULTS     all tool_results for a turn → ONE user message.
MUST-HOLD   money / identity / compliance → hooks & gates, not prompts.
HOOKS       pre-tool interception = block/redirect;  PostToolUse = normalise results.
SUBAGENTS   Task tool; allowedTools includes "Task"; pass context explicitly; parallel = many Task calls in ONE turn.
NARROW?     whole areas missing, subagents "succeeded" → coordinator decomposition too narrow.
TOOLS       description = selection signal; 4–5 tools per agent; rename/split overlaps.
TOOL_CHOICE auto | any (must call some) | {"type":"tool","name"} (must call X) | none.
ERRORS      isError + category + isRetryable; empty ≠ failure.
MCP         .mcp.json (team, ${ENV}) vs ~/.claude.json (personal); resources = catalogues.
CLAUDE.md   ~/.claude (you) | repo (team) | subdir; @import; .claude/rules + paths; /memory.
SKILLS      context: fork | allowed-tools | argument-hint; personal variant = new name.
PLAN MODE   architecture / multi-file → plan; clear single fix → direct.
CI          claude -p ; --output-format json --json-schema ; independent reviewer.
BATCH       50% off, ≤24h, no SLA, custom_id, no mid-request tools; never for blocking checks.
SCHEMA      kills syntax errors, not semantic ones; nullable for absent data; enum+other+detail.
RETRY       with specific error; useless when info is absent.
CONTEXT     case-facts block; trim tool output; key findings first; scratchpad; /compact.
ESCALATE    explicit human request | policy gap | no progress. Not sentiment/confidence.
REVIEW      segment accuracy by type & field; stratified sampling; calibrated confidence.
PROVENANCE  claim→source+date; keep conflicting values, annotated.

📚 Official resources

• Anthropic Partner Academy and the official exam guide: anthropic-partners.skilljar.com
• Free Anthropic Academy courses: anthropic.skilljar.com (Building with the Claude API, Claude Code in Action, Introduction to MCP, MCP Advanced Topics, Introduction to agent skills, Introduction to subagents)
• Claude API docs: platform.claude.com/docs · Claude Code and Agent SDK docs: code.claude.com/docs · MCP: modelcontextprotocol.io
• Pearson VUE Claude certification page: pearsonvue.com/us/en/anthropic.html

🏁 Exam-day tactics

1. Read the final line of each question first: “most effective first step“, “most likely root cause”, “choose TWO”.
2. Underline constraint words: guarantee, must, every developer, without committing secrets, cost is the priority.
3. Eliminate options that fix a different problem or over-engineer a first step.
4. In multiple-response items, judge each option independently.
5. Flag anything over 3 minutes and come back to it. Never leave a blank.
6. For online testing: clear desk, one monitor, system check done, ID ready 30 minutes early.

🧪 Exam-Style Practice Questions

Try these before opening the answers. They use the same scenario style as the real exam.

Question 1. Which coordinator prompt style best lets subagents adapt?

• A. "Do your best"
• B. Research goals plus quality criteria (coverage, source types, recency)
• C. A full transcript of past runs
• D. A numbered list of exact search queries to run

Question 2. The agent keeps using built-in Grep instead of your more capable `code_search` MCP tool. What's the first fix?

• A. Rename it to `grep2`
• B. Improve the MCP tool's description to explain its capabilities and outputs
• C. Remove Grep
• D. Move the server to user scope

Question 3. Developers dismiss many findings, and you want to analyse which code constructs cause false positives. What should you add to the findings schema?

• A. `detected_pattern`
• B. `model_version`
• C. `timestamp`
• D. `sentiment`

📝 Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

1. Task 1: Put the six-week plan in your calendar with fixed study slots.
   ✅ Done when: Six weekly study slots are in your calendar, with the module or lab for each slot named.
2. Task 2: Print the cheat sheet and mark the lines you cannot explain yet.
   ✅ Done when: Every line of the cheat sheet you could not explain is marked, and you revisited its lesson.
3. Stretch: take all five mock tests and book the exam once three are 85% or higher.
   ✅ Done when: You have three mock scores of 85% or higher before booking the exam.

❓ Frequently Asked Questions

🤔 How long should I study for CCAR-F?

About six weeks at six to eight hours a week if you already build software.

🤔 What score should I aim for on mock tests?

At least 85% on three mocks before booking the real exam.

🤔 What happens if I fail?

You can retake after 14 days, then 30, then 90, with up to four attempts in a rolling twelve months.

🤔 Is the exam open book?

No. Notes, documentation and AI assistants are not allowed.

🏁 Summary

You have finished the course. Now take the timed mock tests.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.

The exam rewards judgement you only build by doing. These eight labs follow the official preparation exercises and cover all five domains. Each ends with a “prove it” check — if you can explain the answer, you’re ready for that topic.

🛑 Lab 1: Your first calls and stop reasons (45 min)

1. Send a basic request; print stop_reason and usage.
2. Set max_tokens=20 on a long answer and observe "max_tokens".
3. Add a system prompt and compare the behaviour.

Prove it: name every stop_reason and what your code should do for each.

🔁 Lab 2: Agentic loop with structured errors (90 min)

1. Define get_customer and lookup_order with detailed descriptions.
2. Implement the loop on stop_reason.
3. Return a transient error (retryable) and a business error (not retryable); watch how Claude reacts.
4. Add a code gate: no lookup_order until get_customer returns verified.

Prove it: explain the three loop-termination anti-patterns.

🧪 Lab 3: Structured extraction pipeline (90 min)

1. Create a record_invoice tool with nullable fields, an enum with “other” + detail, and calculated vs stated totals.
2. Feed an invoice with no PO number — confirm you get null, not an invented value.
3. Validate with Pydantic; retry with the document, the failed output and the specific error.
4. Add two few-shot examples for different layouts and compare empty-field rates.

Prove it: list which failures retries fix and which they can’t.

📦 Lab 4: Message Batches (45 min)

1. Submit 20 requests with custom_ids; poll until ended.
2. Match results by custom_id (note the order).
3. Resubmit only the failed IDs after chunking oversized inputs.

Prove it: calculate the submission cadence for a 30-hour SLA.

🤖 Lab 5: Agent SDK coordinator, subagents and hooks (2 h)

1. Define searcher, analyst and synthesizer AgentDefinitions with scoped tools.
2. Include "Task" in the coordinator’s allowedTools; check it emits parallel Task calls in one turn.
3. Pass findings explicitly as structured JSON with source URL and date.
4. Add a PostToolUse hook that normalises dates, and a pre-tool hook that blocks rm -rf.
5. Simulate a timeout and return structured error context; confirm the report lists coverage gaps.

Prove it: show that a subagent can’t see the coordinator’s history unless you pass it.

🧪 Lab 6: Claude Code team configuration (90 min)

1. Run /init; add a personal preference in ~/.claude/CLAUDE.md; confirm both with /memory.
2. Create .claude/rules/testing.md with paths: ["**/*.test.*"] and check when it loads.
3. Add .claude/commands/review.md and a skill with context: fork, allowed-tools and argument-hint.
4. Configure .mcp.json with ${GITHUB_TOKEN} plus a personal server; confirm both are available.
5. Try a one-line fix directly and a 30-file change in plan mode.

Prove it: explain why a teammate wouldn’t receive your user-level rules.

🔌 Lab 7: Build an MCP server (2 h)

1. With the Python MCP SDK, expose search_tickets and get_ticket tools and a tickets://catalog resource.
2. Return isError with categories for failures, and an empty list (not an error) for no matches.
3. Connect it to Claude Code over stdio; improve descriptions until Claude prefers it over Grep.

Prove it: explain when to use a resource instead of a tool.

🔍 Lab 8: CI review bot (90 min)

1. In a GitHub Actions job, run claude -p with --output-format json --json-schema.
2. Put explicit report/skip criteria and a severity rubric in CLAUDE.md.
3. Compare a single pass with per-file plus integration passes on a 14-file PR.
4. Re-run after a new commit, passing earlier findings, and confirm there are no duplicate comments.

Prove it: explain why “only report high-confidence findings” doesn’t reduce false positives.

📝 Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

1. Task 1: Complete Labs 1–3 and keep your code in one repository.
   ✅ Done when: Labs 1–3 run end to end from a clean checkout, using only the README you wrote.
2. Task 2: Complete Labs 5–7 and write two sentences on what surprised you in each.
   ✅ Done when: Each of Labs 5–7 has two sentences of notes covering what surprised you and what you would do differently.
3. Stretch: finish Lab 8 and run it on a real pull request.
   ✅ Done when: Your CI review bot posted at least one useful comment on a real pull request without duplicates.

❓ Frequently Asked Questions

🤔 Do I need to pay for the labs?

You need a Claude API key with credit for API labs; Claude Code needs an eligible plan or API access.

🤔 Which language should I use?

Python or TypeScript. The labs use Python examples, and both SDKs work the same way.

🤔 How long do the labs take?

About 12 hours in total, spread over the six-week study plan.

🤔 Are the labs required to pass?

No, but the exam tests practical judgement, which the labs build faster than reading.

🏁 Summary

Next, continue with Claude Architect Exam: 6-Week Study Plan, Cheat Sheet and Exam-Day Tips.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.

“97% accurate” can still be unsafe to automate. The final two task statements cover how to prove accuracy before removing humans, and how to keep track of where every claim came from (Task Statements 5.5 and 5.6).

🚧 Aggregate accuracy hides weak segments

97% overall can mask 70% on handwritten invoices or on one particular field. Before reducing human review, analyse accuracy by document type and by field.

📏 Measuring and routing

• Stratified random sampling of high-confidence extractions measures ongoing error rates and catches new failure patterns.
• Field-level confidence scores must be calibrated against a labelled validation set before you set review thresholds.
• With limited reviewer capacity, route low-confidence and ambiguous or contradictory documents to humans first.

🔗 Provenance in multi-source synthesis

• Summaries drop attribution — require claim → source mappings (URL or document, excerpt, date) that synthesis must preserve and merge.
• Conflicting figures from credible sources: keep both, attributed, and annotate the conflict. Never pick one arbitrarily or average them.
• Publication and collection dates stop a change over time from being misread as a contradiction.
• Separate well-established from contested findings in the report.
• Render content by type: financial data as tables, news as prose, technical findings as structured lists.

🧪 Exam-Style Practice Questions

Try these before opening the answers. They use the same scenario style as the real exam.

Question 1. How should you measure error rates among *high-confidence* extractions on an ongoing basis?

• A. Run monthly full re-extractions
• B. Review only low-confidence items
• C. Assume they're correct
• D. Use stratified random sampling for human verification

Question 2. How should field-level confidence thresholds for routing to human review be set?

• A. Ask the model for the threshold
• B. Calibrate them against a labelled validation set
• C. Pick 0.8 by intuition
• D. Copy another team's value

Question 3. A synthesis report converts quarterly revenue figures, news events and technical findings into uniform paragraphs, and readers struggle. What's better?

• A. Use JSON for everything
• B. Render each type appropriately: financial data as tables, news as prose, technical findings as structured lists
• C. Use bullet points for everything
• D. Keep everything as prose

📝 Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

1. Task 1: Break a sample accuracy figure down by document type and field and find the weakest segment.
   ✅ Done when: Your breakdown shows at least two segments and identifies the weakest by name and accuracy.
2. Task 2: Design a routing rule that sends low-confidence and contradictory documents to reviewers first.
   ✅ Done when: Your rule uses a calibrated threshold and sends contradictory documents to review regardless of confidence.
3. Stretch: write a synthesis output that keeps two conflicting statistics with sources and dates.
   ✅ Done when: Both statistics appear with their source and date, and the text says plainly that they conflict.

❓ Frequently Asked Questions

🤔 Is 97% accuracy enough to remove human review?

Not until you check accuracy by document type and field, because the overall figure can hide weak segments.

🤔 What is stratified sampling used for?

Measuring error rates in high-confidence outputs over time and spotting new error patterns.

🤔 How should confidence thresholds be set?

Calibrate them against a labelled validation set, not by intuition.

🤔 What if two sources disagree?

Keep both values with attribution and annotate the conflict rather than picking one.

🏁 Summary

• Segment accuracy by document type and field before automating.
• Stratified sampling plus calibrated confidence drive review routing.
• Keep claim-source-date mappings; preserve and annotate conflicts.

Next, continue with Claude Architect Hands-on Labs: 8 Practical Exercises.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.

Escalate too often and you miss your resolution target; escalate too rarely and the agent takes actions it shouldn’t. The exam has a clear model of good escalation and error propagation (Task Statements 5.2 and 5.3).

📞 Valid escalation triggers

❓ Ambiguous matches

When a lookup returns several customers, ask for an additional identifier. Never pick one by heuristic (most recent, first result).

🚨 Error propagation in multi-agent systems

• Return structured error context: failure type, the query attempted, partial results and possible alternatives.
• Distinguish access failures (timeouts needing a retry decision) from valid empty results.
• Recover transient failures locally; propagate only what can’t be resolved.
• Anti-patterns: silently suppressing errors (empty result marked success) and terminating the whole workflow on one failure.
• Annotate synthesis output with coverage gaps where sources were unavailable.

🧪 Exam-Style Practice Questions

Try these before opening the answers. They use the same scenario style as the real exam.

Question 1. A frustrated customer has a standard, in-policy issue and hasn't asked for a human. What should the agent do?

• A. Escalate immediately
• B. Acknowledge the frustration and offer to resolve it, escalating if they then ask for a human
• C. Close the ticket
• D. Ignore the emotion

Question 2. Why are sentiment scores and self-reported confidence poor escalation triggers?

• A. They're illegal
• B. They require fine-tuning
• C. They don't reliably reflect how complex a case actually is
• D. They're expensive

Question 3. What's the purpose of a crash-recovery manifest in a multi-agent system?

• A. Each agent exports its state to a known location, and on resume the coordinator loads the manifest and injects that state into agent prompts
• B. Logging prompts for audit
• C. Billing
• D. Caching prompts

📝 Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

1. Task 1: Write three escalate and three resolve examples for a support system prompt.
   ✅ Done when: Each example states the trigger, and none of the escalate examples relies on sentiment or a confidence score.
2. Task 2: Write the structured error a timed-out search subagent should return, including partial results.
   ✅ Done when: Your error includes the failure type, the query attempted, partial results and at least one alternative.
3. Stretch: add a coverage-gaps section to a sample research report.
   ✅ Done when: Your report has a coverage-gaps section that names the missing source and the affected findings.

❓ Frequently Asked Questions

🤔 When should a support agent escalate immediately?

When the customer explicitly asks for a human.

🤔 Is customer frustration a reason to escalate?

Not on its own. Acknowledge it, resolve the issue if you can, and escalate if they then ask for a human.

🤔 What should the agent do with several matching customers?

Ask for another identifier instead of guessing.

🤔 Why not return an empty result when a search fails?

It hides the failure, so the coordinator cannot retry or report the gap.

🏁 Summary

• Escalate on explicit request, policy gaps or no progress — not on sentiment or confidence.
• Multiple matches → ask for another identifier.
• Propagate structured error context; never hide errors or kill the whole run.

Next, continue with Human Review, Confidence Calibration and Source Provenance.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.

Long conversations and long explorations degrade in predictable ways. The exam tests the patterns that keep critical information intact (Task Statements 5.1 and 5.4).

⚙️ Progressive summarisation loses precision

Rolling summaries turn “a £184.20 refund on order #A-7710 by Thursday” into “a refund is pending”. Keep a persistent case-facts block — amounts, order IDs, dates, statuses, promises and customer-stated constraints — and include it in every prompt, outside the summarised history.

<case_facts>
customer_id: C-1042 (verified)
order: #A-7710 · refund £184.20 approved · promised by Thu 14 Nov
constraint: technician visits after 17:00 only
</case_facts>

🛠️ Trim tool output before it piles up

An order lookup may return 40+ fields when only 5 matter. Trim results to the relevant fields (for example in a PostToolUse hook) before they accumulate in context. Upstream agents should return structured key facts, citations and relevance scores — not long reasoning chains — when downstream context budgets are tight.

🎯 Lost in the middle

Models reliably use information at the beginning and end of long inputs but may miss findings in the middle. Put a key-findings summary first and organise details under explicit section headers. And always send the complete conversation history — the API is stateless.

🗂️ Long codebase explorations

• Symptoms of degradation: inconsistent answers, and talk of “typical patterns” instead of the specific classes found earlier.
• Scratchpad files record key findings for later questions.
• Subagents investigate focused questions (“find all test files”) while the main agent keeps the big picture.
• Phase summaries are injected before the next phase begins.
• /compact reduces context use when verbose discovery output fills it.
• Crash-recovery manifests: each agent exports its state to a known location; on resume the coordinator loads the manifest and injects that state into agent prompts.

🧪 Exam-Style Practice Questions

Try these before opening the answers. They use the same scenario style as the real exam.

Question 1. Aggregated subagent results put the key findings in the middle of a 60-page input, and the synthesis misses them. What helps?

• A. Remove the headers
• B. Increase the temperature
• C. Shuffle the order
• D. Put a key-findings summary at the beginning and organise the details under clear section headers

Question 2. A long exploration fills context with noisy grep output. Which built-in command reduces context usage?

• A. `/mcp`
• B. `/init`
• C. `/compact`
• D. `/memory`

Question 3. A downstream agent has a small context budget. What should upstream agents return?

• A. Structured key facts, citations and relevance scores
• B. Raw HTML
• C. Nothing until asked
• D. Full reasoning chains

📝 Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

1. Task 1: Design a case-facts block for a support conversation with order ID, amount, deadline and one customer constraint.
   ✅ Done when: Your block keeps exact amounts, IDs, dates and the customer constraint, and fits in under 80 words.
2. Task 2: Trim a 40-field API response down to the five fields a refund decision needs.
   ✅ Done when: Your trimmed response keeps only the five fields the refund decision needs, with names unchanged.
3. Stretch: run a long Claude Code exploration with a scratchpad file and use /compact when context fills.
   ✅ Done when: Claude still names the specific classes it found earlier after /compact, using your scratchpad file.

❓ Frequently Asked Questions

🤔 Why do summaries lose important details?

Progressive summarisation compresses exact numbers, dates and promises into vague phrases.

🤔 What is the lost-in-the-middle effect?

Models use the start and end of long inputs more reliably than the middle, so put key findings first.

🤔 What does /compact do?

It reduces context use in Claude Code when verbose output has filled the conversation.

🤔 How do multi-agent systems recover from a crash?

Each agent exports its state to a known location, and the coordinator reloads a manifest on resume.

🏁 Summary

• Case facts live outside the summary, in every prompt.
• Trim tool output; summarise key findings first.
• Scratchpads, subagents, /compact and manifests keep long work accurate.

Next, continue with Escalation Rules and Error Propagation in Claude Agents.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.

Batch processing questions are pure judgement: when is cheaper-but-slower acceptable? The exam also asks how to design reviews that stay accurate at scale (Task Statements 4.5 and 4.6).

📦 Message Batches API facts

• 50% cost savings compared with synchronous calls.
• Processing can take up to 24 hours; no latency SLA.
• Results are correlated with custom_id — they can arrive in any order.
• No multi-turn tool calling inside a single request (tools can’t run mid-request).
• You poll for completion.

📦 Batch or synchronous?

⏱️ SLA submission maths

If results are due within 30 hours and a batch can take 24 hours, a document arriving just after a submission waits until the next one. Submitting every 4 hours gives a worst case of 4 + 24 = 28 hours — inside the SLA. Every 8 hours (32 h) or 12 hours (36 h) can miss it.

🚨 Handling failures

Resubmit only the failed custom_ids, with a fix applied (for example, chunk documents that exceeded the context limit). Before a large run, refine the prompt on a representative sample to maximise first-pass success.

🔍 Multi-instance and multi-pass review

• Independent reviewer: a second Claude instance without the generator’s reasoning context catches more than self-review instructions or extended thinking in the same session.
• Multi-pass: per-file passes for local issues plus a cross-file integration pass.
• Confidence per finding: useful for routing reviewer attention once calibrated — not as ground truth.

🧪 Exam-Style Practice Questions

Try these before opening the answers. They use the same scenario style as the real exam.

Question 1. Which properties apply to the Message Batches API? *(Choose two)*

• A. Guaranteed 5-minute latency
• B. Multi-turn tool calling within a request
• C. 50% cost savings
• D. Results returned in submission order
• E. Up to 24-hour processing window

Question 2. Results are due within 30 hours, and batches can take up to 24 hours to process. Which submission cadence safely meets the SLA?

• A. Every 8 hours
• B. Every 12 hours
• C. Every 4 hours
• D. Once a day

Question 3. Why is an independent Claude instance better than self-review for generated code?

• A. It's cheaper
• B. Self-review is disallowed
• C. The generating session keeps its own reasoning context and is less likely to question its own decisions
• D. It uses a different tokenizer

📝 Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

1. Task 1: Submit a batch of 20 requests with custom_id values and match the results by ID.
   ✅ Done when: All 20 results are matched to their requests by custom_id, even though they arrive in a different order.
2. Task 2: Calculate the submission cadence needed for a 30-hour SLA with 24-hour batch processing.
   ✅ Done when: Your answer is every 4 hours or more often, with the worst-case arithmetic written out.
3. Stretch: resubmit only failed requests after chunking the oversized inputs.
   ✅ Done when: Only the failed custom_ids are resubmitted, and the resubmitted requests succeed.

❓ Frequently Asked Questions

🤔 How much cheaper is the Message Batches API?

About 50% compared with standard synchronous calls.

🤔 How long can a batch take?

Up to 24 hours, with no latency guarantee.

🤔 Can I use batches for pre-merge checks?

No. Developers are waiting on those, so they need synchronous calls.

🤔 How do I match batch results to requests?

Use the custom_id you set on each request, because results can arrive in any order.

🏁 Summary

• Batches: 50% off, ≤ 24 h, no SLA, custom_id, no mid-request tools.
• Never put a blocking workflow on batches.
• Resubmit only failures; refine prompts on a sample first.

Next, continue with Claude Context Management: Case Facts, Lost-in-the-Middle and /compact.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.

Structured extraction is a whole exam scenario. You need to know how to guarantee valid JSON, how to design schemas that don’t push Claude to invent data, and when a retry will — and won’t — fix a problem (Task Statements 4.3 and 4.4).

🛠️ tool_use as the structured-output mechanism

Define an “extraction tool” whose input_schema is your output schema. Claude’s tool call arguments are your structured data — syntactically valid and schema-compliant.

{
  "name": "record_invoice",
  "description": "Record fields extracted from ONE supplier invoice.",
  "input_schema": {
    "type": "object",
    "properties": {
      "vendor": {"type": "string"},
      "invoice_date": {"type": ["string", "null"], "description": "ISO-8601; null if absent"},
      "po_number": {"type": ["string", "null"]},
      "category": {"type": "string", "enum": ["hardware", "software", "services", "other", "unclear"]},
      "category_detail": {"type": ["string", "null"]},
      "stated_total": {"type": "number"},
      "calculated_total": {"type": "number"},
      "conflict_detected": {"type": "boolean"}
    },
    "required": ["vendor", "category", "stated_total", "calculated_total", "conflict_detected"]
  }
}

📏 Schema design rules

• Nullable for possibly-absent data. A required field the document doesn’t contain pushes the model to fabricate a value.
• Enum + “other” + detail string for extensible categories, and “unclear” for genuinely ambiguous cases.
• Self-check fields such as calculated_total next to stated_total, plus conflict_detected.
• Format rules in the prompt (dates to ISO-8601, amounts as numbers) alongside the schema.

🔁 Validation and retry loops

When validation fails, send a follow-up with the original document, the failed extraction and the specific validation error.

In review pipelines, add a detected_pattern field to findings so you can analyse which code constructs developers keep dismissing.

🧪 Exam-Style Practice Questions

Try these before opening the answers. They use the same scenario style as the real exam.

Question 1. Which schema design reduces fabrication?

• A. Make fields that may be missing from the source nullable or optional
• B. Remove all enums
• C. Make every field required
• D. Use free-text fields only

Question 2. What can a retry with validation-error feedback **not** fix?

• A. A value that doesn't exist anywhere in the provided document
• B. A date in the wrong format
• C. A string where a number was expected
• D. A missing required key

Question 3. Why use tool_use with a JSON schema for extraction?

• A. It reliably produces schema-compliant, syntactically valid structured output
• B. It removes the need for validation
• C. It's cheaper than text
• D. It makes outputs semantically correct

📝 Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

1. Task 1: Define an extraction tool with one nullable field and an enum with other and unclear values.
   ✅ Done when: Your schema has a nullable field, an enum containing other and unclear, and a detail string for the other value.
2. Task 2: Process a document missing one field and confirm you get null, not a made-up value.
   ✅ Done when: The missing field comes back as null in three runs out of three.
3. Stretch: build a validation-retry loop that sends the document, the failed output and the exact error.
   ✅ Done when: A deliberately wrong date format is corrected on the retry, and your log shows the exact error you sent back.

❓ Frequently Asked Questions

🤔 How do I guarantee valid JSON from Claude?

Define a tool whose input schema is your output schema and read Claude's tool_use arguments.

🤔 Does a JSON schema guarantee correct data?

No. It stops syntax errors, but values can still be wrong, such as totals that don't add up.

🤔 Why make fields nullable?

A required field that is missing from the document pushes the model to invent a value.

🤔 When does retrying fail?

When the information is not in the provided source. Return null and route the document to a human.

🏁 Summary

• tool_use + JSON schema = reliable structure; validate semantics separately.
• Nullable fields prevent fabrication; enum “other” + detail keeps categories extensible.
• Retry with specific feedback for format errors; never retry missing information.

Next, continue with Claude Message Batches API and Multi-Pass Review Design.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.

Two prompt-engineering skills dominate the exam: writing explicit criteria instead of vague instructions, and using few-shot examples when instructions alone give inconsistent results (Task Statements 4.1 and 4.2).

⚙️ Explicit criteria beat vague instructions

🤝 Protect developer trust

A category with many false positives makes developers ignore all findings, including accurate security ones. Temporarily disable the noisy category while you improve its prompt, then re-enable it.

🧪 Few-shot examples

• Few-shot examples are the most effective way to get consistently formatted, actionable output when detailed instructions still vary.
• Use 2–4 targeted examples of ambiguous cases, and show the reasoning for why one option beat the plausible alternatives.
• Good examples help Claude generalise to new cases rather than just pattern-match.
• Show the exact output format (location, issue, severity, suggested fix).
• Contrast acceptable patterns with genuine issues to cut false positives.
• For extraction, show documents with different structures (inline citations vs bibliography, tables vs narrative) to reduce empty fields and hallucinations.

<example>
Code: user = repo.find(id)  # reflection-based DI injects repo
Finding: none
Reasoning: repo looks unused but is injected via reflection — acceptable pattern.
</example>
<example>
Code: total = price * qty; return round(total)
Finding: {location: "cart.py:42", issue: "rounds currency with float", severity: "high",
          fix: "use Decimal and quantize to 2 places"}
Reasoning: float rounding loses cents in real orders.
</example>

🧪 Exam-Style Practice Questions

Try these before opening the answers. They use the same scenario style as the real exam.

Question 1. A review prompt says "check that comments are accurate" and flags many harmless comments. What's the best rewrite?

• A. "Only report high-confidence issues."
• B. "Ignore comments."
• C. "Be conservative."
• D. "Flag a comment only when the behaviour it describes contradicts what the code actually does."

Question 2. Detailed instructions still give inconsistently formatted findings. What's the most effective technique?

• A. Lower `max_tokens`
• B. A larger model
• C. More instructions
• D. Few-shot examples showing the exact format (location, issue, severity, fix)

Question 3. The "naming" findings category has an 80% dismissal rate, and developers have started ignoring *all* findings. What's the best immediate action?

• A. Raise the severity of everything
• B. Temporarily disable the naming category while you improve its prompt, to restore trust
• C. Switch models
• D. Keep everything and add a disclaimer

📝 Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

1. Task 1: Rewrite a vague review instruction from your team as explicit report and skip criteria.
   ✅ Done when: Your rewrite lists what to report and what to skip, with no words such as 'be careful' or 'high confidence'.
2. Task 2: Write a severity rubric with one code example per level.
   ✅ Done when: Each severity level has one short code example that a teammate would classify the same way.
3. Stretch: add three few-shot examples to a prompt and measure the change in format consistency over ten runs.
   ✅ Done when: You recorded format consistency for ten runs before and after adding the examples.

❓ Frequently Asked Questions

🤔 Does 'only report high-confidence findings' reduce false positives?

No. The exam guide notes that vague confidence instructions don't improve precision; explicit categorical criteria do.

🤔 How many few-shot examples should I use?

Two to four targeted examples of ambiguous cases, with the reasoning for each choice.

🤔 Why disable a noisy review category?

High false-positive categories make developers ignore all findings, including accurate ones.

🤔 Do few-shot examples help extraction?

Yes. Examples that cover different document layouts reduce empty and invented fields.

🏁 Summary

• Replace vague instructions with categorical report/skip criteria.
• Disable noisy categories temporarily to restore trust.
• 2–4 targeted few-shot examples with reasoning give consistency and generalisation.

Next, continue with Claude Structured Output with tool_use and JSON Schema.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.

Running Claude Code in CI is where QA and automation engineers get the most value — and where the exam asks very practical questions about flags and review design (Task Statement 3.6).

⚙️ Non-interactive mode

claude -p "Review the diff in $DIFF_FILE for bugs and security issues only" \
  --output-format json \
  --json-schema ./review-findings.schema.json

• -p / --print runs non-interactively: process the prompt, print, exit. Without it, the job hangs waiting for input.
• --output-format json with --json-schema gives machine-parseable findings you can post as inline PR comments.

⚙️ Give CI the project context

CI-invoked Claude Code reads the project CLAUDE.md. Document testing standards, what makes a test valuable, available fixtures and review criteria there. For test generation, include the existing test files so Claude doesn’t suggest scenarios you already cover.

🔍 Independent review instances

The session that generated code keeps its own reasoning context and is less likely to question its own decisions. Review generated code with a separate, independent Claude invocation.

🔍 Re-running reviews after new commits

Include the earlier findings in context and ask Claude to report only new or still-unaddressed issues. Otherwise every push re-posts the same comments.

🧪 Exam-Style Practice Questions

Try these before opening the answers. They use the same scenario style as the real exam.

Question 1. A CI job running `claude "review this"` hangs. What's the fix?

• A. `CLAUDE_HEADLESS=true`
• B. Pipe in `yes`
• C. `claude -p "review this"`
• D. `claude –batch`

Question 2. After a developer pushes fixes, the re-run review repeats 14 already-resolved comments. What's the best fix?

• A. Include the prior findings in context and ask for only new or still-unaddressed issues
• B. Delete the old comments automatically
• C. Lower `max_tokens`
• D. Run reviews weekly

Question 3. Your CI posts Claude's review findings as inline PR comments. What output configuration should you use?

• A. Markdown output
• B. Default text output parsed with regexes
• C. `–verbose`
• D. `–output-format json` with `–json-schema` defining the findings structure

📝 Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

1. Task 1: Run claude -p with –output-format json on a sample diff and save the output.
   ✅ Done when: The command exits on its own and the saved file is valid JSON.
2. Task 2: Write a JSON schema for findings with file, line, severity, category and suggested fix, and use it with –json-schema.
   ✅ Done when: The output validates against your schema, and every finding has a file, line and severity.
3. Stretch: add a GitHub Actions step that posts findings as PR comments and skips issues already reported.
   ✅ Done when: A second run after a new commit posts only new or still-open findings, with no duplicates.

❓ Frequently Asked Questions

🤔 Why does Claude Code hang in my CI job?

It is running interactively. Add -p (or –print) so it processes the prompt, prints and exits.

🤔 How do I get structured output from Claude Code in CI?

Use –output-format json together with –json-schema.

🤔 Should the same session review the code it generated?

No. An independent instance without the generator's context catches more issues.

🤔 How do I avoid duplicate review comments after new commits?

Pass the earlier findings in context and ask only for new or still-unaddressed issues.

🏁 Summary

• claude -p + --output-format json + --json-schema.
• CLAUDE.md carries the review criteria and testing standards into CI.
• Use an independent reviewer; pass earlier findings to avoid duplicate comments.

Next, continue with Prompt Engineering for Claude: Explicit Criteria and Few-Shot Examples.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.

Choosing the right working mode saves hours of rework. The exam tests when to plan first, when to just make the change, and how to steer Claude when its output isn’t what you meant (Task Statements 3.4 and 3.5).

🗺️ Plan mode or direct execution?

Combine them: plan the migration, agree the approach, then execute the plan directly.

🤖 The Explore subagent

Explore isolates verbose discovery (file listings, grep output) and returns a summary, preserving the main conversation’s context during multi-phase tasks.

🔄 Iterative refinement techniques

• Concrete input/output examples — when prose descriptions are interpreted inconsistently, give 2–3 examples of input and expected output.
• Test-driven iteration — write tests first (including edge cases and performance), then iterate by sharing failures.
• The interview pattern — ask Claude to question you first in unfamiliar domains, surfacing issues like cache invalidation and failure modes.
• Interacting vs independent issues — put interacting problems in one detailed message; fix independent ones one at a time.

🧪 Exam-Style Practice Questions

Try these before opening the answers. They use the same scenario style as the real exam.

Question 1. Which tasks suit **plan mode**? *(Choose two)*

• A. Restructuring a monolith into services
• B. Renaming a local variable
• C. Choosing between two message-queue integrations with different infrastructure needs
• D. Adding a single `if` validation
• E. Fixing a typo in a log message

Question 2. You're building a caching layer in a domain you don't know well. Which technique surfaces the considerations you haven't thought of?

• A. The interview pattern: have Claude ask you questions before implementing
• B. Direct execution
• C. Few-shot examples
• D. `/compact`

Question 3. Three bugs interact: fixing the parser changes the validator's input, which changes the formatter. How should you raise them?

• A. One at a time, in separate messages
• B. Only the first; the rest will resolve themselves
• C. Through three parallel sessions
• D. All in one detailed message, explaining the interactions

📝 Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

1. Task 1: Do a one-line fix in direct execution and a ten-file rename in plan mode, and compare the experience.
   ✅ Done when: You wrote two sentences comparing time spent and rework for the two modes.
2. Task 2: Give Claude two input and output examples for a data transformation and compare the result with a prose-only request.
   ✅ Done when: The example-driven request gives the expected output on the first or second try, and you noted how many tries prose needed.
3. Stretch: start an unfamiliar feature with the interview pattern and list the questions Claude asked you.
   ✅ Done when: You listed at least three questions Claude asked and one design change they led to.

❓ Frequently Asked Questions

🤔 When should I use plan mode in Claude Code?

For large, multi-file or architectural changes and when there are several valid approaches to compare.

🤔 When is direct execution better?

For clear, scoped changes such as a single-file bug fix with a stack trace.

🤔 What is the Explore subagent for?

It runs noisy discovery in isolation and returns a summary, keeping the main context clean.

🤔 What is the interview pattern?

Asking Claude to question you before building, so it surfaces design issues you had not considered.

🏁 Summary

• Plan for architecture and multi-file work; act directly on clear, scoped fixes.
• Explore keeps discovery noise out of the main context.
• Examples and tests beat longer prose instructions.

Next, continue with Claude Code in CI/CD: -p Flag, JSON Output and Automated PR Review.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.