Claude Certified Associate – Foundations
Exam code CCAO-F. This single page holds two things: a fast high-level overview to orient you, and a thorough study guide covering every exam domain, worked examples, decision tables, and study materials. This exam is written for business and productivity users — no coding, no API calls, no SDKs. If you have never written a line of code, you are exactly who this certification is for. Overview items link straight into their deep-dive sections.
60 questions 120 minutes 720/1000 to pass $99 USD Valid 12 monthsPart 1 — High-Level Overview
What & Why
The Claude Certified Associate – Foundations credential validates that you can apply Claude to real business and productivity tasks with minimal guidance: using built-in platform features to streamline work, spotting where Claude could improve a process, weighing quality against speed and cost, and knowing when a task is too technical for you and belongs with a Claude Architect or Claude Developer instead. It is Anthropic's own foundational, non-engineering certification, sitting at the base of the Claude Certification Program alongside the Developer and Architect tracks.
You are not expected to write code, call an API, or configure an SDK. You are expected to write a clear prompt, judge whether the answer is trustworthy, pick the right Claude surface and model for a job, set up a shared Project sensibly, and recognize a data-handling or governance problem before it happens.
Exam at a Glance
| Attribute | Value |
|---|---|
| Exam code | CCAO-F |
| Questions | 60, standalone items (no multi-question scenarios) |
| Question types | Multiple choice & multiple response — each item states how many responses to select |
| Time | 120 minutes |
| Passing score | 720 out of 100–1000 (scaled, criterion-referenced) |
| Cost | 99 USD |
| Delivery | Pearson VUE — online proctored or a Pearson test center, closed book |
| Validity | 12 months, free on-time renewal assessment |
The 7 Domains
Anthropic's own Exam Guide PDF publishes seven weighted content domains. Output Evaluation is the single biggest chunk — this is fundamentally a "can you judge Claude's work" exam, not a "can you write a clever prompt" exam.
| Domain | What it tests | Deep dive |
|---|---|---|
| 1 · Prompting 14% | Writing effective prompts, decomposing complex requests, iterating, adapting strategy to task type. | → §3 |
| 2 · Output Evaluation 21% | Judging accuracy, catching hallucinations and bias, fact-checking, knowing when a human must review, choosing an output format. | → §4 |
| 3 · Product & Model Selection 12% | Picking the right Claude feature and model for the job, managing context and memory. | → §5 |
| 4 · Workflow Integration 16% | Using Claude for requirements analysis, research, process redesign, and explaining Claude's value and limits to others. | → §6 |
| 5 · Configuration 12% | Setting up Projects with instructions and knowledge sources, connectors, keeping configuration current. | → §7 |
| 6 · Governance & Responsible Use 15% | Appropriate use cases, data sensitivity and privacy, organizational policy, ethics. | → §8 |
| 7 · Troubleshooting 10% | Diagnosing a weak prompt or poor output, adjusting approach, optimizing a workflow. | → §10 |
Core Skill Snapshot
If you master this shortlist, you cover the majority of questions. Each links to its detailed treatment.
Prompting
Clear instructions, examples, role framing, step-by-step structure, iteration. → detailsJudging output
Hallucination spotting, fact-checking, knowing when to escalate to a human. → detailsClaude surfaces
Chat, Projects, Artifacts, research mode, and matching Haiku/Sonnet/Opus to the task. → detailsConfiguration
Project instructions, uploaded knowledge, connectors, keeping it current. → detailsResponsible use
What never to paste in, organizational policy, bias awareness. → detailsTeam adoption
Shared Projects, consistent prompts, admin basics. → detailsRecommended Materials
This is a brand-new certification (the exam guide is dated July 2026), so the practice-question market is thin and full of low-quality guesswork. The only material worth trusting fully is Anthropic's own.
Study Plan (Quick Version)
Built on learning science — active recall + spaced repetition — but the real engine here is daily hands-on use. You cannot cram judgment about AI output quality; you build it by using Claude on real tasks and checking your own work.
- Days 1–3: Read the exam guide's blueprint, skim Anthropic's help center for Projects/Artifacts/Memory/Skills, and start a daily prompt journal.
- Days 4–9: Use Claude on real work every day. After each session, write down one prompt that worked and one that didn't, and redo the weak one.
- Days 10–12: Study Domains 2 and 6 hard (Output Evaluation and Governance are the two most conceptually dense, together over a third of the exam). Teach the shared-responsibility-style "what Claude can and can't do" idea out loud.
- Days 13–14: Work every worked example in this guide, review the Cram Jam, sleep well — don't cram new material.
→ Detailed retention-based plan (§13) · ⚡ Cram Jam one-pager · → Exam-day tips & traps (§14)
Part 2 — Thorough Study Guide
1 · Exam Details
The certification validates that a candidate can apply Claude to complete business and productivity tasks with minimal guidance: using built-in features and tools to streamline workflows, identifying opportunities to improve a process with Claude, selecting an approach that balances quality, efficiency, and cost, and recognizing limitations that should be escalated to a Claude Architect or Claude Developer.
Who it's for
Professionals who use Claude as a productivity tool and build Claude Projects, across operations, marketing, project management, education, communications, and general knowledge work — both internal staff and external consultants. The guide is explicit that this is not for software developers who build against APIs or design agentic systems, and candidates are not expected to design enterprise-scale AI architectures; that scope belongs to the Architect and Developer credentials. There are no mandatory prerequisites, and no software-development or API experience is needed — the credential is awarded on exam performance alone.
Scoring mechanics
- 60 items, standalone. Each is a self-contained multiple-choice or multiple-response question — there are no shared-scenario item sets. Multiple-response items tell you how many answers to select.
- Scaled score 100–1000, pass at 720. It is criterion-referenced: you are measured against a fixed performance standard set by a formal standard-setting study, not ranked against other candidates.
- Your score report shows pass/fail plus percent-correct by domain — useful for retake prep, but domain scores do not themselves determine pass/fail; only the total scaled score does.
Logistics
| Item | Detail |
|---|---|
| Price | 99 USD (partner-tier discounts may apply at checkout). |
| Delivery | Pearson VUE, online proctored or at a Pearson VUE test center. Closed book: no Claude, no documentation, no browser tabs, no external tools, no notes, phones, or secondary monitors. |
| Registration | Through the Anthropic Partner Academy; you create a Pearson VUE account to schedule. You can cancel or reschedule up to 24 hours ahead without penalty. |
| Retakes | Waiting periods of 14 / 30 / 90 days after the 1st / 2nd / 3rd failed attempt; up to 4 attempts per exam within a rolling 12 months. Full fee applies each attempt. |
| Validity & renewal | 12 months from the award date. Renew on time with a free, non-proctored assessment; a lapsed credential requires retaking the full paid exam. |
| Before you sit | You must accept a confidentiality/non-disclosure agreement before the exam starts, and you must review the Exam Guide, Certification Terms and Conditions, and Certification Exam Policy beforehand. |
2 · What Claude Actually Is
A surprising number of exam-worthy mistakes come from a fuzzy mental model of what a large language model actually does. Get this part solid first — it underlies almost every other domain.
2.1 · What an LLM Is (and Isn't)
Claude is a large language model (LLM): a system trained on enormous amounts of text to predict, one piece at a time, what text should come next given everything before it. From that simple mechanism, useful behavior emerges — Claude can summarize, draft, explain, translate, brainstorm, and reason through multi-step problems in plain language.
- Claude is not a search engine. Left to its training data alone, it does not "look things up" — it generates plausible, fluent text. This is why it can state a false fact with complete confidence: fluency and accuracy are not the same thing.
- Claude is not a database. It does not query a system of record for exact figures, and it does not know today's date, your company's internal numbers, or anything after its training cutoff unless you provide it or it uses a connected tool like web search.
- Claude does not "remember" by default the way a person does — see §5.3 for what Memory and context actually do.
- Claude is a tool you direct, not an autonomous coworker with judgment equal to a human's. It has no stake in the outcome, no accountability, and no ability to independently verify a claim against reality unless you give it a way to check.
2.2 · Tokens & the Context Window
Claude reads and writes in tokens, roughly chunks of a word (a short word is often one token; a long or unusual word may be several). You don't need to count tokens by hand, but two consequences matter for daily use:
- The context window is the total amount of text — your prompt, any uploaded files, the conversation history, and Claude's reply — that fits into one exchange. It is large, but it is finite. A very long conversation or a huge pasted document can fill it.
- When context fills up or a conversation gets too long and wandering, quality degrades: Claude may lose track of an instruction from early in the chat, or conflate details. The fix is not "add more instructions" — it's to start a fresh conversation, summarize what matters so far, or move stable, reusable context into a Project (see §7.1) instead of re-pasting it every time.
- Uploaded files count against the same context budget. A very large file or a large number of files may need to be trimmed, summarized, or split into a follow-up question rather than one giant ask.
2.3 · The Model Lineup
Anthropic offers Claude in a small family of models, generally described along a speed/cost vs. depth-of-reasoning spectrum. Exact model names, versions, and specific limits change over time — check Anthropic's current documentation for what's live today — but the three-tier shape is stable and is explicitly named in the exam blueprint:
| Tier | Best for |
|---|---|
| Haiku (fastest, cheapest) | High-volume, low-complexity tasks: quick replies, simple classification or extraction, short drafts where speed matters more than depth. |
| Sonnet (balanced) | The everyday default for most business writing, analysis, and drafting — a strong balance of quality, speed, and cost for typical knowledge work. |
| Opus (most capable) | Complex reasoning, high-stakes analysis, long or nuanced documents, and tasks where getting it right matters more than getting it fast or cheap. |
3 · Prompting & Task Execution Domain 1 · 14%
Objectives: create effective prompts for business and technical tasks, apply task decomposition, iterate to improve output, and adapt strategy to task type.
3.1 · The Seven Prompting Moves
These are drawn from Anthropic's own published prompt-engineering guidance, translated for a non-technical audience. None of them require special syntax — they are ways of thinking about what you ask for.
- Be clear and direct. State the task, the audience, the format, and the length up front, the way you'd brief a new hire who can't read your mind. Vague asks get vague answers.
- Give it a role. "You are an experienced grant writer reviewing this proposal for clarity" focuses tone and priorities far better than no framing at all.
- Show examples. One or two examples of the input/output pattern you want ("here's a sample of the tone we use") teach a format faster than a paragraph of description.
- Let it think in steps. For anything with real reasoning (comparing options, working through a policy question), ask Claude to reason through the problem before giving a final answer — this improves quality on non-trivial tasks.
- Structure a long or complex prompt. When a request has several distinct parts (background, constraints, the actual ask), separate them clearly — headings or numbered sections — so nothing gets missed or blended together.
- Give it the material, not just the question. Paste in the actual document, data, or draft rather than describing it from memory; Claude works from what's in front of it, not what you assume it already knows.
- Tell it what "done" looks like. Specify the acceptance bar: "flag anything you're not confident about," "keep it under 200 words," "match this style guide" — this is what turns a first draft into a usable one.
| Move | When it helps most | One-line example |
|---|---|---|
| Give context | Claude doesn't know your team, product, or situation | "We're a 12-person nonprofit; this goes to first-time donors." |
| Be specific | The task has more than one reasonable interpretation | "Trim to 150 words, keep the second paragraph's numbers." |
| Give examples | You want a particular tone or format matched exactly | "Match this style: [paste one sample sentence]." |
| Assign a role | You want a specific lens or priority applied | "You're reviewing this as a skeptical procurement officer." |
| Ask for a format | The output feeds a next step (comparison, import, forwarding) | "Return this as a table with columns Name, Date, Amount." |
| Set constraints | There's a real limit — length, audience, what to avoid | "Under 200 words, no jargon, don't mention pricing." |
| Decompose | The ask has several distinct deliverables | "First just outline it. I'll approve before you draft it in full." |
| Iterate | The first draft is close but not right | "Keep the structure, but make the tone warmer." |
3.2 · Task Decomposition
A single sprawling request ("reorganize our onboarding process and also draft the new email templates and also summarize stakeholder feedback") reliably produces a worse result than the same work broken into steps. Task decomposition means splitting a complex ask into smaller, ordered pieces, often across separate turns in the same conversation:
Before
"Fix our customer onboarding process." (Too broad — Claude has to guess what "fix" means and for whom.)After
Turn 1: "List the current onboarding steps from this document and flag where users seem to drop off." Turn 2: "For the two worst drop-off points, propose two alternatives each." Turn 3: "Draft the email copy for the option we picked."Decomposition also makes output easier to evaluate — you can check each small step before building on it, instead of discovering a flawed assumption buried inside a huge final answer.
3.3 · Iterating on a Prompt
The first draft of a prompt is rarely the best one. Treat it like editing: read the actual output, name specifically what's wrong ("too formal," "missed the Q3 numbers," "assumed the wrong audience"), and revise the prompt rather than manually rewriting the output every time.
Before
"Summarize this report." → gets a generic, oddly-focused summary.After
"Summarize this report in 5 bullet points for a VP audience who cares about budget impact and timeline risk, not methodology." → gets a summary that's actually usable.3.4 · Matching Strategy to Task Type
| Task type | What changes about the prompt |
|---|---|
| Analysis | Give the source material directly, state the specific question, ask for reasoning steps before the conclusion. |
| Research | Be explicit about scope and recency needs; if current information matters, use a Claude surface with web search rather than relying on training knowledge alone (see §5.1). |
| Drafting | Provide examples of tone/format, specify audience and length, ask for a first pass rather than a "final" version. |
| Brainstorming | Ask for a wide, unfiltered set of options first, then a separate follow-up to narrow or rank them — mixing generation and judgment in one prompt narrows the ideas too early. |
A more granular breakdown, by the nine task types the exam blueprint touches on most:
| Task type | What to give Claude | What to ask for | How to check it |
|---|---|---|---|
| Summarize | The full source document | Length, audience, and what to prioritize | Spot-check 2-3 claims against the source |
| Extract | The source and the exact fields you need | A table or list with consistent fields | Confirm every row against the source, not just a sample |
| Draft | Goal, audience, tone or a sample | A first pass, not a final version | Read for factual claims and tone fit, then iterate |
| Rewrite | The original text and what should change | What to preserve (facts, structure) vs. what to change (tone, length) | Diff the meaning against the original, not just the wording |
| Analyze | The data or documents and the specific question | Reasoning steps before the conclusion | Sanity-check the reasoning, not just the final number |
| Compare | Both items and the criteria that matter to you | A structured table, not a paragraph | Verify each criterion independently rather than trusting the summary row |
| Brainstorm | The constraint and the goal, minimal filtering | A wide list first, ranking as a separate step | Check that ideas are actually distinct, not restatements |
| Translate | The text and the target audience/register | A draft translation, flagged for idioms or ambiguity | Have a fluent human reviewer check anything customer-facing or legal |
| Classify | The item and the exact categories allowed | One category per item, with a stated reason | Review borderline cases by hand; don't assume 100% consistency |
3.5 · Common Prompt Failures
Most weak prompts fail in one of a handful of predictable ways. Recognizing the pattern in the output tells you which part of the prompt to fix.
| Failure | Symptom in the output | The fix |
|---|---|---|
| Vague ask | Generic, unfocused, technically responsive but not useful | Add audience, purpose, and what "good" looks like |
| Missing context | Reasonable-sounding but wrong for your actual situation | Paste the real document, data, or background instead of describing it |
| Too many asks at once | Shallow on every part, misses at least one entirely | Decompose into ordered steps (§3.2) |
| Wrong format requested | Correct content, unusable shape (prose when you needed a table) | Name the exact structure you need up front |
| Leading question | Output agrees with the framing rather than giving an independent read | Ask neutrally first ("what are the risks here?"), not "don't you think this is a bad idea?" |
4 · Output Evaluation & Validation Domain 2 · 21%
The largest domain on the exam. Objectives: evaluate outputs for accuracy and completeness, identify hallucinations/inconsistencies/bias, apply fact-checking, determine when human review is required, and edit/organize output into the right format.
4.1 · Spotting Hallucinations
A hallucination is fluent, confident, wrong output — a fabricated citation, a plausible-sounding statistic that doesn't exist, a policy detail invented to fill a gap. Confidence in Claude's tone is not evidence of accuracy; a hallucinated fact and a correct one can read identically.
- Highest-risk spots: specific numbers, dates, named sources, legal or regulatory citations, quotes attributed to a real person or document, and anything about very recent events.
- Checklist: does the claim cite something checkable? Can you find that source independently? Does the number match a document you already have? Would this claim be embarrassing or costly if wrong — and if so, is it verified yet?
- Asking Claude to self-rate its confidence and trusting a high score is not a validation technique — self-reported confidence is not a reliable accuracy signal. Verify against an authoritative source instead.
Hallucinations aren't all the same shape. Recognizing which kind you're looking at speeds up the check:
| Type | What it looks like | Why it happens | How to catch it |
|---|---|---|---|
| Invented facts | A specific detail — a policy clause, a product feature — that sounds plausible but doesn't exist | The model fills a gap in its knowledge with the most statistically likely-sounding text | Ask "where does this come from" and check the source directly |
| Invented citations | A named source, article, or case that doesn't exist or doesn't say what's claimed | Citations are a common, high-confidence surface for fabrication when the real source wasn't provided | Look up the citation independently before using it |
| Wrong numbers | A statistic, total, or date that's close to right but off, or entirely fabricated | Language models predict plausible text, not arithmetic or lookups, unless given the actual data | Recompute or cross-check against the source document |
| Confident vagueness | An answer that sounds complete but is actually generic filler dressed in specific-sounding language | Fluent phrasing can mask a lack of real substance | Ask "what specifically supports this" and see if a real answer follows |
| Outdated information | A correct-as-of-training-cutoff fact presented as current | Claude's training knowledge has a cutoff and no built-in sense of "today" unless told | For anything time-sensitive, use a surface with web search or supply current data (§5.1) |
| Misread source document | A summary or extraction that quietly contradicts or misstates the document you provided | Long or dense documents increase the chance a detail gets blended, dropped, or misattributed | Spot-check the summary's specific claims against the original, not just its overall shape |
4.2 · Fact-Checking & When to Escalate to a Human
Not every output needs the same level of scrutiny — match the check to the stakes:
| Stakes | Appropriate check |
|---|---|
| Low (internal brainstorm, first draft) | Skim for obvious errors; refine as you go. |
| Medium (external-facing draft, internal report) | Check factual claims against your own source documents; have a colleague skim before sending. |
| High (legal, financial, medical, regulatory, anything going to a customer or regulator) | Verify every specific claim against an authoritative source, and route through the human expert or process your organization already requires for that category — Claude output does not change that requirement. |
Framed the other way — by the actual document you're producing, and who has to stand behind it:
| Stakes | Verification required | Who signs off |
|---|---|---|
| Throwaway draft (personal notes, a first pass you'll rework) | None beyond a quick sanity read | You, informally |
| Internal document (team memo, internal report) | Check factual claims that matter to the decision being made | You, or a colleague on a quick skim |
| Customer-facing (email, proposal, public post) | Verify every specific claim, name, and figure against a source | You plus a reviewer before it goes out |
| Regulated or legal (compliance language, contracts, medical or financial advice) | Full verification against authoritative sources, no exceptions | The qualified human expert or process your organization already requires — unchanged by Claude being involved |
Escalating to a human (or to a Claude Architect/Developer for a technical build) is a core, tested skill, not an admission of failure. Signals it's time to escalate: the task requires professional judgment you're not qualified to give (legal, medical, financial advice), the stakes of being wrong are high and unverifiable, or the task has moved from "using Claude" to "building a technical integration."
4.3 · Editing, Refining & Choosing an Output Format
Part of evaluation is deciding how the output should be packaged, not just whether its content is right:
- Inline chat text — fine for a quick answer, a short explanation, or something you'll copy a sentence or two from.
- An Artifact — better for anything you'll keep editing, share as a standalone document, or that benefits from a dedicated view (a long document, a table, a simple mockup). See §5.1.
- Structured data (a table, a list with consistent fields) — better than prose when the next step is comparison, sorting, or feeding it into another tool.
Editing and adapting output for its actual audience — trimming jargon for an executive summary, adding detail for a technical reviewer — is itself a tested skill, not a "nice to have" after the fact.
4.4 · Output Evaluation Rubric
This is the highest-weighted domain on the exam — a working checklist matters more here than anywhere else in the guide. Run any consequential output past these six dimensions before it goes anywhere:
| Dimension | What to check | How to check it quickly | What a failure looks like |
|---|---|---|---|
| Accuracy | Are the facts, numbers, and claims actually true | Spot-check specific claims against a source you trust | A confident, specific-sounding statement that turns out to be fabricated or wrong |
| Completeness | Does it answer the whole question, not just part of it | Reread the original ask and check each part was addressed | A polished answer to only one of three things you asked |
| Relevance | Is it actually useful for what you asked, not just technically responsive | Ask "would this help the actual audience make a decision" | Generic content that could apply to almost any similar request |
| Tone | Does it match the audience and occasion | Read it as the recipient would | Overly casual for an executive, or stiff and jargon-heavy for a general reader |
| Format | Is it structured the way the next step needs | Check if you can use it as-is or have to reformat it first | A wall of prose when the next step needed a table or list |
| Sourcing | Can every specific claim be traced back to something checkable | Ask "where did this come from" for any number, quote, or citation | A statistic or quote with no traceable origin |
5 · Product & Model Selection Domain 3 · 12%
Objectives: select the right Claude product feature, differentiate model types, align model choice with task requirements, and manage context/memory considerations.
5.1 · Chat, Projects, Artifacts, Research
| Surface | What it's for |
|---|---|
| A one-off chat | A single question or task with no need to reuse context later — quick, disposable, no setup. |
| A Project | Recurring work that shares context: instructions, reference documents, and a consistent voice across many conversations. See §7.1. |
| An Artifact | A standalone piece of output you'll keep, edit, or share separately from the chat — a document, a table, a simple interactive view — rather than scrolling back through conversation text to find it. |
| Research / web search | Tasks that need current information beyond Claude's training knowledge — recent events, current prices, today's status of something. Turn it off when currency doesn't matter and speed or a controlled, closed set of sources does. |
The full surface map, including the pieces covered in more depth elsewhere in this guide:
| Surface | What it is | When to reach for it | The mistake people make with it |
|---|---|---|---|
| Chat | A single conversation with no persistent shared setup | A quick, one-off question or task | Re-explaining the same standing context every single time instead of moving it into a Project |
| Projects | A container of shared instructions, knowledge, and chats | Recurring work a team or individual repeats often | Treating it as "set once, forget forever" instead of reviewing it (§7.3) |
| Artifacts | A standalone, editable view of a piece of output | Anything you'll keep, edit, export, or share on its own | Leaving finished work buried in chat scroll instead of promoting it to an Artifact |
| Research / web search | A mode that lets Claude pull current information from outside its training data | Anything time-sensitive: current events, prices, live status | Leaving it on for pure analysis of material you already supplied, adding noise and latency for no benefit |
| Connectors | A live link to an external system (drive, mailbox, workspace tool) | Recurring need for current data from a system of record | Connecting a whole mailbox or drive when only one folder's worth of content was actually needed (§7.2) |
| Skills | A saved, repeatable way of doing a specific task | A task pattern your team performs the same way often enough to standardize | Building a one-off Skill for something that only happens once, instead of just prompting directly |
| Memory | Carries relevant detail forward from past conversations automatically | Personal convenience across your own sessions | Assuming memory is a substitute for documented, team-visible Project instructions (§5.3) |
5.2 · Choosing a Model
Reuse the tiering from §2.3: match model capability to task complexity, not the other way around. A high-volume, low-complexity job (short customer-reply drafts, simple tagging) run through the most expensive, slowest model wastes budget and time without buying meaningfully better output. A complex, high-stakes analysis run through the fastest, cheapest model risks a shallower result than the task deserves.
| Tier (conceptual) | Typical fit | Tradeoff |
|---|---|---|
| Fast / small | High-volume, low-complexity, latency-sensitive work — simple replies, tagging, short extraction | Cheapest and quickest, but shallower on nuance and multi-step reasoning |
| Balanced | Everyday business writing, analysis, and drafting | The default good-enough choice for most tasks; not the deepest option for genuinely hard problems |
| Most capable | Complex reasoning, high-stakes analysis, long or nuanced documents | Slower and costlier — worth it only when depth actually changes the outcome |
Exact model names, generation numbers, and which tier is "current" all change over time — this table is deliberately generic. Check Anthropic's current model documentation for what's live today rather than memorizing a name.
5.3 · Managing Context & Memory
Two related but different things:
- Context is what's visible to Claude right now — this conversation, any files attached to it, and a Project's instructions/knowledge if you're in one. It resets with a new chat (outside a Project's persistent knowledge).
- Memory, where available, lets Claude carry forward relevant details from your past conversations so you don't have to restate your role or preferences every time. It is a convenience layer, not a substitute for putting stable, important instructions in a Project where the whole team can see and edit them.
Know when to restart, summarize, or persist: restart a conversation that's grown long and inconsistent; summarize progress before restarting if you need continuity; persist genuinely stable, reusable information (style guides, standing instructions, reference documents) in a Project instead of re-explaining it every session.
6 · Workflow Integration & Solution Design Domain 4 · 16%
Objectives: analyze requirements and use cases, use Claude for research/planning/process optimization, support solution design and iteration, integrate Claude into existing workflows, and communicate Claude's value and limits to stakeholders.
6.1 · Analyzing a Use Case
Before automating or augmenting a process with Claude, ask three questions: Is this task language-shaped? (drafting, summarizing, classifying, extracting, explaining — Claude's strengths). Is the risk of an error tolerable given the review step you'll put around it? Does a person still need to own the outcome? A process where the answer to the third question is "no, it can run unsupervised" is usually a sign the task has moved beyond this certification's scope and needs an engineer to build proper guardrails.
6.2 · Workflow Recipes
Five patterns cover most business use of Claude. Each is really the same shape: give Claude the material, be specific about the transformation you want, specify the audience and format.
| Recipe | Shape of the prompt |
|---|---|
| Summarize | Paste the source, state the audience and length, name what to prioritize (decisions, risks, numbers — not "everything"). |
| Extract | Paste the source, specify exactly which fields/values to pull and the format to return them in (a table is usually easiest to check). |
| Draft | Give the goal, audience, tone/examples, and length; ask for a first pass, then iterate rather than expecting a final version immediately. |
| Analyze | Give the data or documents, ask a specific question, request the reasoning before the conclusion so you can sanity-check it. |
| Translate | Provide the text and target audience/register (formal vs. casual, technical vs. general); for anything customer-facing or legal, have a fluent human reviewer check it — translation nuance is a real evaluation risk. |
The same six recipes again, this time by what triggers reaching for Claude at all and what to check before you actually use the result:
| Recurring task | Trigger | Prompt pattern | Check before you use it |
|---|---|---|---|
| Weekly status summary | A report or thread has piled up and needs distilling for an audience that won't read the whole thing | Paste the source, name the audience and what to prioritize, ask for a fixed length | Spot-check 2-3 claims against the source; confirm nothing decision-relevant was dropped |
| Data extraction into a table | The same fields need pulling from many similar documents | Paste one example, specify the exact fields and the output format | Confirm every row, not a sample — extraction errors don't announce themselves |
| First-draft external email | A routine but customer-facing message needs writing | Give goal, audience, tone, and constraints; ask for a first pass | Verify every fact and figure before sending; check tone reads right for the recipient |
| Rewriting for a new audience | Existing content needs to work for a different reader (technical → exec, formal → casual) | Give the original and name what must stay the same vs. change | Confirm meaning survived the rewrite, not just that the wording changed |
| Comparing options | A decision needs weighing two or more choices against criteria that matter | Give both items and your criteria, ask for a structured table | Verify each criterion's cell independently — don't trust a single "winner" line |
| Brainstorming a solution set | A problem needs more options than the room has generated on its own | State the constraint and goal, ask for a wide list before any ranking | Check ideas are genuinely distinct, not the same idea worded five ways |
| Classifying a backlog | A queue of items needs sorting into a fixed set of categories | Give the items and the exact allowed categories, ask for one category plus a reason per item | Hand-review borderline or low-confidence items rather than assuming full consistency |
6.3 · Communicating Value & Limits to Stakeholders
Part of this domain is explaining Claude accurately to colleagues who haven't studied it: what it speeds up (drafting, first passes, structuring), what it doesn't replace (accountability, verified facts, domain expertise, final sign-off on anything regulated), and where the review step lives in a new workflow. Overselling what Claude can do to a stakeholder creates exactly the kind of ungoverned, unverified use that Domain 6 exists to prevent.
6.4 · Escalation Signals
Not every gap belongs to the same fix. Three different escalation targets show up on this exam, and mixing them up is a common wrong answer:
| Sign you're seeing | Escalate to | Why that target |
|---|---|---|
| The task needs an API integration, custom automation, or an agentic system wired into other software | Claude Developer | Building against the API and designing agentic systems is explicitly outside Associate scope |
| The task needs enterprise-scale architecture decisions — how Claude fits across many systems and teams | Claude Architect | Architecture-level design is a separate, higher-scope credential |
| The output needs legal, medical, financial, or other specialist judgment | The qualified human expert your organization already uses | No amount of Claude configuration substitutes for professional accountability |
| The stakes of an error are high and you genuinely can't verify the claim yourself | A human reviewer with the standing to check it | Verification effort has to scale with stakes (§4.2), and some verification requires expertise you may not have |
7 · Configuration & Knowledge Management Domain 5 · 12%
Objectives: configure Projects with instructions and knowledge sources, manage uploaded knowledge and connectors, write effective system-level instructions, and keep configuration current.
7.1 · Configuring a Project
A Project bundles three things: instructions (standing guidance Claude follows in every chat inside the Project — tone, format, constraints, "always do X"), knowledge sources (reference documents everyone in the Project can draw on without re-uploading them each time), and the chats themselves, which share that context. Use a Project the moment a task repeats — see the decision table in §11.
Writing a good system-level instruction
- State the Project's purpose and audience up front, not just a list of rules.
- Be specific about tone and format ("always answer in a table," "never use jargon without defining it").
- Name what's out of bounds as clearly as what's expected — an instruction that only says what to do leaves gaps around what not to do.
- Keep it short enough that a teammate can actually read and remember it; a wall of rules gets skimmed and ignored.
The most common configuration mistake is putting the right content in the wrong place. A quick sort:
| Goes in | What belongs there | Example |
|---|---|---|
| Project instructions | Standing rules that apply to every chat in the Project — tone, format, constraints, scope | "Always answer in a table." "Never quote a price without flagging it as an estimate." |
| Uploaded knowledge | Reference material chats can draw on but that isn't a rule about behavior — documents, data, past examples | The current style guide, last quarter's report, a set of approved product descriptions |
| The individual prompt | What's specific to this one request and not reusable — this week's numbers, this one recipient, today's exact ask | "Using the above, draft this week's update for the Tuesday leadership meeting." |
7.2 · Uploaded Knowledge & Connectors
Uploading a file puts specific content directly in front of Claude for that Project or chat — good for a fixed document (a policy, a style guide, last quarter's report) that doesn't change often. Connectors link Claude to a live external source (a shared drive, an email account, a workspace tool) so it can pull current information without you manually exporting and re-uploading it every time. See the "file vs. connector" line in §11 for exactly when each fits.
Zooming out to every way information reaches Claude, not just the two above:
| Knowledge source | Freshness | General size limits | When to use | Failure mode |
|---|---|---|---|---|
| Pasted text | As current as what you typed, right now | Small — a paragraph or two before it's easier to upload instead | Quick, one-off context you won't reuse | Gets lost once the chat ends; nobody else can find it later |
| Uploaded file | Fixed as of upload — stale the moment the source changes | Finite and counted against context; large files may need trimming or splitting — check current limits rather than assuming | A stable reference document that doesn't change often | |
| Project knowledge | Fixed as of upload, same as any file, but shared and visible to the whole Project | Same general constraints as an uploaded file, aggregated across everything in the Project | Reference material the whole team should draw on consistently | |
| Connector | Live — reflects the connected system as of the moment it's queried | Governed by the connected system, not a fixed upload size | Recurring need for current data from a system of record | |
| Web search | Live, public web as of the search | Not applicable in the same sense — bounded by what a search returns | Current events, prices, or status not covered by anything you've provided |
7.3 · Maintaining Instructions Over Time
Configuration goes stale: a style guide gets revised, a policy changes, a Project's purpose drifts as the team's work evolves. Treat Project instructions and knowledge sources like any other living document — review them periodically, remove outdated files, and update instructions when you notice Claude following guidance that no longer matches how the team actually works.
8 · Responsible & Safe Use Domain 6 · 15%
Objectives: identify appropriate and inappropriate use cases, apply data-sensitivity/regulatory/privacy considerations, follow organizational AI policy, and understand the ethical implications of AI use.
8.1 · The Usage Policy in Practice
Anthropic publishes a Usage Policy that sets the outer bounds of acceptable use of Claude — prohibiting things like generating content for illegal activity, weapons development, deliberate deception at scale, and other clearly harmful uses. For this exam, the practical takeaway is simpler than memorizing every clause: Claude is a tool, and the person directing it is responsible for how it's used. Two layers of judgment apply on top of Anthropic's policy: your organization's own AI usage policy (often stricter, and specific to your industry), and plain professional judgment about a use case that seems fine in the abstract but is wrong for a specific, sensitive situation.
Three layers, working together in practice:
| Layer | Sets | What happens if it's ignored |
|---|---|---|
| Anthropic's Usage Policy | The outer bound of acceptable use for everyone, everywhere | Access to Claude itself can be restricted — this floor isn't negotiable at the individual or org level |
| Your organization's AI policy | Rules specific to your industry, data, and risk tolerance, usually stricter than the floor above | An org-level compliance or data-handling incident, even if Anthropic's policy was technically followed |
| Individual professional judgment | The specific, situational call neither policy could fully anticipate | A use case that's technically permitted but wrong for this particular sensitive situation |
8.2 · What Never to Paste In
The single most testable, practical habit in this whole domain: know what categories of information should not go into a prompt, an upload, or a connector without your organization's explicit sign-off.
- Secrets and credentials — passwords, API keys, access tokens, internal system details.
- Regulated personal data — health information, financial account details, government ID numbers, anything covered by a privacy regulation your organization must comply with — unless it has been redacted or anonymized and policy allows the remaining use.
- Other people's personal data you don't have a clear right or need to share, even if it's "just for internal analysis."
- Confidential business information beyond what the task actually requires — trade secrets, unreleased financials, legal strategy.
- Anything your organization's policy specifically restricts, even if it seems harmless to you personally — the point of an org policy is that individual judgment isn't the final word on regulated data.
The same five categories, with the reasoning and the safer path for each:
| Category | Why it's a problem | Safer alternative |
|---|---|---|
| Secrets and credentials | A prompt or upload isn't a secure secrets store, and exposure can compromise a system well beyond the current task | Never include them; reference that a credential exists without pasting its value |
| Regulated personal data | Privacy regulations govern how this data can be processed and by whom, independent of intent | Redact or anonymize identifiers before sharing, or get explicit policy clearance first |
| Other people's personal data | You may not have the right or the need to share it, even internally | Ask whether the task actually requires the personal detail, or just the pattern behind it |
| Confidential business information | Trade secrets, unreleased financials, or legal strategy carry consequences beyond the immediate task if exposed | Share only the minimum needed for the task, not the full underlying document |
| Unreleased material | Pre-announcement product, financial, or legal information can carry disclosure or insider-trading implications if it leaks | Treat it with the same handling rules as any other pre-release confidential document |
8.3 · Bias, Transparency & Ethics
- Bias: Claude's output reflects patterns in its training data and can carry the same biases present in that data. Treat outputs touching hiring, performance evaluation, lending, or other consequential decisions about people with extra scrutiny, and keep a human decision-maker accountable for the outcome.
- Transparency with colleagues and customers: don't present AI-drafted work as entirely human-authored when that distinction matters to the audience, and don't hide from a colleague that a shared document or analysis started as an AI draft — this is both an ethics point and a practical trust issue on a team.
- Human oversight: the recurring theme across this domain is that Claude assists judgment, it doesn't replace the accountable human — captured concretely in "recognize when human review, validation, or escalation is required" from the Minimally Qualified Candidate profile.
9 · Working with Claude in a Team
Not a separately weighted exam domain on its own, but it threads through Domains 4, 5, and 6 (workflow integration, configuration, and governance), and it's where most of the "how do we actually roll this out" real-world value lives.
9.1 · Shared Projects
A Project shared across a team turns individual prompting skill into an organizational asset: one set of instructions, one set of reference documents, one consistent voice, instead of every person reinventing their own approach (and their own mistakes) from scratch. The team member who sets up the Project should document why each instruction exists, not just what it says — that context is what lets someone else maintain it later.
9.2 · Admin & Team Concepts
Organizations using Claude at team or enterprise scale typically have an administrator role responsible for provisioning access, setting organization-wide policy defaults, and managing which connectors and data sources are permitted. Specific plan names, seat limits, and admin controls change over time and vary by current offering — check Anthropic's current plan and admin documentation rather than relying on a fixed number here. The concept that's stable and exam-relevant: administrative and governance controls exist at the organization level precisely so that individual judgment isn't the only line of defense for the concerns in §8.
9.3 · Getting Adoption Without Chaos
- Start with one well-scoped Project for a real, recurring pain point, not a company-wide mandate on day one — a working example spreads faster than a policy memo.
- Write down the guardrails once (what data can go in, what needs human review, which model tier for which task) so new team members inherit judgment instead of rediscovering it themselves.
- Expect uneven skill levels. Some teammates will write excellent prompts immediately; others need the worked examples and decision tables in this guide. Pair people rather than assuming a single training session fixes it.
- Revisit configuration periodically (§7.3) — adoption chaos usually shows up months in, as instructions drift out of date and nobody owns updating them.
10 · Troubleshooting & Optimization Domain 7 · 10%
Objectives: identify, diagnose, and resolve issues with underperforming prompts or poor outputs; adjust approach based on feedback and results; optimize workflows for efficiency and effectiveness.
| Symptom | Likely cause | Fix |
|---|---|---|
| Output is generic or misses the point | Prompt was too vague, or the wrong context was provided | Add specifics: audience, format, length, what to prioritize (§3.1) |
| Output is confidently wrong | Hallucination, or a question outside what Claude can actually know | Verify facts independently; provide the source material instead of relying on recall (§4.1) |
| Claude "forgets" an earlier instruction | Conversation has grown too long, filling the context window | Summarize and restart, or move standing instructions into a Project (§2.2, §5.3) |
| Answers are inconsistent across a team | No shared instructions or reference material | Consolidate into a shared Project (§7.1, §9.1) |
| Task is taking too long / costing too much | Wrong model tier for the task, or task not decomposed | Match model to complexity (§5.2); break the task into steps (§3.2) |
| Output format is unusable downstream | Didn't specify format needs | Ask for the specific structure you need — table, list, Artifact (§4.3) |
11 · Decision Guides
The exam frequently gives you two plausible-sounding options and expects you to pick the one that actually fits. Memorize these discriminators.
Project vs. one-off chat
| Situation | Choose |
|---|---|
| Task repeats weekly with the same tone/format/reference material | Project |
| One-time question, no reuse expected | One-off chat |
| Team needs a consistent voice across many people | Project |
| Sensitive, one-off exploration you don't want lingering as reusable context | One-off chat (and mind §8.2 regardless) |
Upload a file vs. paste text
| Situation | Choose |
|---|---|
| Long document, spreadsheet, or something you'll reference again | Upload |
| A short paragraph or two, quick one-off context | Paste |
| Data needs to persist for a whole Project's lifetime | Upload as a Project knowledge source |
| Content changes frequently and lives in a live system | Connector, if your org permits it, rather than repeated manual uploads |
When to use an Artifact
| Situation | Choose |
|---|---|
| Output you'll keep editing, export, or share standalone | Artifact |
| Quick answer you'll read once and move on | Inline chat text |
| Structured content (table, list, document) that benefits from its own view | Artifact |
When web search helps vs. hurts
| Situation | Guidance |
|---|---|
| Question needs current events, prices, or status | Helps — turn it on |
| Task is pure drafting/analysis of material you already provided | Hurts or is irrelevant — off, avoid unnecessary latency/noise |
| Highly sensitive internal question with no public answer | Hurts — searching won't help and may not be appropriate to run at all |
When to break a task into steps
| Situation | Guidance |
|---|---|
| Request has multiple distinct deliverables | Decompose (§3.2) |
| You need to check an assumption before building on it | Decompose, verify the first step, then continue |
| Simple, single-purpose ask | One prompt is fine |
When to escalate to a developer or engineer
| Situation | Escalate? |
|---|---|
| Task needs an API integration, custom automation, or agentic system | Yes — Claude Developer/Architect scope |
| Task needs enterprise-scale architecture decisions | Yes — Claude Architect scope |
| Task is a business workflow using built-in features (Projects, Artifacts, connectors already offered) | No — this is Associate scope |
| Output needs specialist judgment you don't have (legal, medical, financial sign-off) | Escalate to the appropriate human expert, not a technical role |
12 · Study Materials
This certification is new — the official Exam Guide is dated July 2026 — so be conservative about anything claiming to be a comprehensive practice-question bank for it. A vendor advertising "guaranteed" real exam questions for a brand-new exam is a red flag, not a shortcut.
1 · Official Anthropic resources (start here)
- The official Exam Guide PDF, available from the certification's page on the Anthropic Partner Academy (anthropic-partners.skilljar.com). Read it in full — it includes the blueprint, sample questions with rationale, scoring, and every policy you're bound by.
- Anthropic's help center and documentation (docs.claude.com and support.claude.com) for Projects, Artifacts, Memory, Skills, and connectors — the exam guide itself points here for feature knowledge, not to a third-party course.
- Anthropic's prompt engineering guidance, the primary source for the techniques in §3.1.
- Anthropic Academy prep courses, if offered for this credential on the Partner Academy platform at the time you're studying — check what's currently listed, since course offerings change.
2 · Community material — read with caution
Because CCAO-F is new, community write-ups and third-party practice exams for it have little track record yet. Treat any third-party practice set as a rough style guide at best, not a predictor of your score, until it has been through at least a few real exam cycles. Prefer material that explains why an answer is correct over material that just hands you an answer key.
3 · What's usually not needed
You do not need a coding environment, an API key, or SDK familiarity to prepare for this exam — if a resource is teaching you to call the Claude API, it's studying for the wrong certification (that's Claude Certified Developer territory). The best preparation is hands-on daily use of Claude on real work, not passive video-watching.
Sources
- Official: Anthropic's CCAO-F Exam Guide PDF (v1.0, effective July 2026), retrieved from the Anthropic Partner Academy · the public Claude Certified Associate – Foundations certification page · Anthropic's public documentation and help center.
- Community: general awareness that third-party practice content for this specific exam is early and unproven as of this writing — verify recency and track record before trusting any of it.
13 · Study Plan (≈2 weeks)
This is a foundational, non-engineering exam, so the plan is short and deliberately hands-on. Passive reading will not build the judgment Domain 2 and Domain 7 test — daily real use will.
The learning principles this plan uses
| Principle | How to apply it to CCAO-F |
|---|---|
| Active recall | After reading a domain's objectives, close the guide and write out what each one means in your own words before checking. |
| Spaced repetition | Revisit your prompt journal and the glossary every few days rather than once at the end. |
| Teach-back | Explain "what a hallucination is and how you'd catch one" or "when to use a Project vs. a chat" out loud to a colleague, unscripted. |
| Deliberate practice | Redo a prompt that didn't work well, don't just move past it — the redo is where the learning happens. |
The daily plan
| Phase | Focus | Actions |
|---|---|---|
| Days 1–2 | Orientation | Read the official Exam Guide PDF in full. Skim Anthropic's documentation for Projects, Artifacts, Memory, Skills, and connectors. Start a prompt journal. |
| Days 3–9 | Daily practice | Use Claude on real work every day: at least one summarize, one draft, and one analyze task across the week. Log one prompt that worked and one that didn't each day; redo the weak one the next day. |
| Days 10–11 | Governance & evaluation deep-dive | Study §4 and §8 hard — together over a third of the exam. Write your own "never paste in" list from memory, then check it against §8.2. |
| Days 12–13 | Practice & decision tables | Work every worked example in §16 without looking at the answer first. Drill the decision tables in §11 until you can answer them from memory. |
| Day 14 | Light review | Skim the Cram Jam and glossary. No new material. Sleep well. |
14 · Exam-Day Tips & Traps
Before you sit
- Closed book, proctored, no exceptions. No Claude, no documentation, no browser tabs, no external tools, no notes, no second monitor, no phone in the room. If testing from home, clear your desk and be prepared for the proctor to review your space on camera.
- Bring a valid, unexpired, government-issued photo ID that matches your registration name exactly.
- You'll accept a confidentiality/non-disclosure agreement before the exam starts — declining ends the session with no refund.
Strategy
- 120 minutes / 60 questions is 2 minutes a question on average — comfortable pacing. Flag anything you're unsure of and move on rather than stalling.
- Items are standalone, not shared scenarios — nothing from question 12 carries into question 13. Read each one fresh.
- Multiple-response items state exactly how many answers to pick — select that number, not more or fewer, even if another option looks tempting.
- When two options both sound reasonable, check which one matches the "verify, don't assume" pattern that runs through Domain 2, or which one keeps a human accountable rather than delegating judgment entirely to Claude.
Recurring traps
- Confidence is not accuracy. A fluent, specific-sounding answer can still be a hallucination — the correct move is almost always independent verification, not trusting the tone.
- "Always use the best/most powerful model" is a wrong-answer pattern. Matching model to task complexity and cost is the tested skill.
- Uploading sensitive data "because it's just for internal use" is a wrong-answer pattern. Redact or anonymize first, or don't proceed without policy clearance.
- This exam is not testing API or coding knowledge. If an answer choice requires writing code, calling an API, or building an integration, it is very likely the wrong choice for an Associate-level item — that's Developer or Architect scope.
- Self-rated confidence from Claude is not validation. Asking Claude "are you sure?" and trusting a confident "yes" doesn't satisfy a fact-checking requirement.
15 · Glossary
| Term | Plain-language meaning |
|---|---|
| LLM (large language model) | An AI system trained on large amounts of text to generate fluent, relevant language in response to a prompt. Claude is an LLM. |
| Prompt | The instruction or question you give Claude. |
| Token | A small chunk of text (roughly part of a word) that Claude reads and writes in; the unit its context window is measured in. |
| Context window | The total amount of text — prompt, files, conversation history, and reply — that fits into one exchange with Claude. |
| Hallucination | Confident, fluent output that is factually wrong or fabricated. |
| Project | A container in Claude for recurring work: shared instructions, reference documents, and the chats that use them. |
| Artifact | A standalone piece of output (document, table, simple interactive view) Claude creates that you can view, edit, and share separately from the chat. |
| Connector | A link between Claude and an external, live data source (like a shared drive or email account) so Claude can use current information from it. |
| Memory | A feature that lets Claude carry forward relevant details from past conversations without you restating them each time. |
| Skill | A repeatable, saved way of doing a specific task that Claude can apply consistently, often shareable across a team. |
| Model tier (Haiku/Sonnet/Opus) | Anthropic's spectrum from fastest/cheapest to most capable; match tier to task complexity. |
| Task decomposition | Breaking a complex request into smaller, ordered steps. |
| Usage policy | Anthropic's published rules for acceptable use of Claude, on top of which your own organization's policy usually adds further restrictions. |
| Escalation | Handing a task off to someone better positioned to own it — a human expert, or a Claude Developer/Architect for technical build work. |
| Standalone item | An exam question that is self-contained, not part of a linked multi-question scenario — the format CCAO-F uses throughout. |
| Scaled score | Your exam result expressed on a fixed 100–1000 scale rather than a raw percentage; 720 is the passing cut score. |
| Criterion-referenced | Scored against a fixed standard of required knowledge, not ranked against other test-takers. |
16 · Worked Example Questions
Standalone items in the exam's own style. Each states how many answers to select, gives an answer, and explains why every distractor is wrong.
1 · Domain 2 — Output Evaluation
Claude drafts a client-facing summary of a new regulation and cites a specific subsection number with full confidence. Before it goes to the compliance team, what should you do? (Select 1.)
- Send it as-is; Claude sounded certain.
- Verify the cited subsection against the official regulation text first.
- Ask Claude to rate its own confidence and send it if the rating is high.
- Reword it to sound more formal, then send it.
Answer: B. Confident tone is not evidence of accuracy, and specific citations are a classic hallucination risk. A is wrong because tone isn't a validity check. C is wrong because self-reported confidence is not a reliable accuracy signal. D is wrong because rewording doesn't touch correctness.
2 · Domain 3 — Product & Model Selection
You need to generate hundreds of short, simple customer-reply drafts where speed and cost matter more than deep reasoning. (Select 1.)
- Use the most capable, highest-cost model for every reply.
- Use a faster, lower-cost model suited to high-volume, straightforward tasks.
- Turn off all product features to cut cost.
- Switch to a different AI platform.
Answer: B. Matching model tier to task complexity is a named skill; the top-tier model wastes budget and latency on simple work. A ignores the cost/speed trade-off. C and D don't address the actual requirement.
3 · Domain 6 — Governance
A colleague wants to upload a spreadsheet of customer names and account numbers so Claude can spot trends. Company policy restricts sharing regulated personal data. (Select 1.)
- Upload it as-is; the analysis is internal.
- Remove or anonymize the identifiers before uploading.
- Upload it but tell Claude not to retain it.
- Skip the analysis.
Answer: B. Redacting or anonymizing regulated identifiers lets the analysis proceed within policy. A violates policy outright. C doesn't satisfy a policy control just because you asked nicely. D is unnecessary once anonymization is possible.
4 · Domain 1 — Prompting
A prompt asking Claude to "improve this email" repeatedly returns generic edits that miss the point. What's the most likely fix? (Select 1.)
- Ask a more capable model the exact same prompt.
- Specify the audience, the goal of the email, and what "improve" should mean (tone, length, persuasiveness).
- Repeat the same prompt several times and pick the best result.
- Shorten the prompt so Claude has less to process.
Answer: B. A vague instruction produces a vague result regardless of model; specificity about audience and goal is the fix. A treats a prompting problem as a model problem. C wastes effort without addressing the ambiguity. D removes information the task actually needs.
5 · Domain 5 — Configuration
A team keeps getting inconsistent tone and formatting from Claude across five different people doing the same weekly report. What should they do? (Select 1.)
- Ask each person to write longer prompts.
- Set up a shared Project with standing instructions and the reference material everyone should use.
- Have one person do all the reports going forward.
- Switch everyone to the same model tier.
Answer: B. A shared Project centralizes instructions and reference material so output is consistent regardless of who's prompting. A doesn't fix inconsistency across people. C avoids the actual problem rather than solving it. D doesn't address tone/format consistency.
6 · Domain 4 — Workflow Integration
A stakeholder asks you to have Claude "just automatically approve routine expense reports without anyone checking." What is the appropriate response? (Select 1.)
- Set it up as requested since it will save time.
- Explain that unsupervised approval removes human accountability and exceeds this role's scope; propose Claude assist with a flagged draft that a person still approves, or escalate the automation to an engineer if full automation is truly needed.
- Refuse to discuss the idea at all.
- Have Claude approve reports but only on Fridays.
Answer: B. This combines recognizing an inappropriate use case (Domain 6) with knowing when to escalate technical automation (workflow scope). A removes needed human oversight. C is unhelpfully dismissive rather than constructive. D doesn't solve the actual concern.
7 · Domain 2 — Output Evaluation
Claude produces a market analysis with a statistic you can't locate in any of your source documents or a quick outside check. (Select 1.)
- Keep the statistic since Claude is generally reliable.
- Remove or flag the statistic until it can be verified against an authoritative source.
- Change the number slightly so it seems more plausible.
- Ask a different AI tool to confirm it.
Answer: B. An unverifiable specific claim should be flagged or removed, not kept on faith. A relies on general reliability rather than checking this specific claim. C fabricates further rather than verifying. D doesn't constitute checking against an authoritative source.
8 · Domain 7 — Troubleshooting
A long-running chat starts giving inconsistent answers and seems to have lost track of an instruction from earlier. (Select 1.)
- Add three more instructions to the same conversation to reinforce the point.
- Summarize what matters so far and start a fresh conversation, moving stable instructions into a Project if they'll be needed again.
- Assume the model is broken and wait a few hours.
- Switch to a less capable model.
Answer: B. This is a context-window symptom; the fix is to reset context, not pile on more instructions into an already-full conversation. A worsens the underlying problem. C misdiagnoses the cause. D doesn't address context length at all.
9 · Domain 3 — Product Selection
You need Claude's answer to reflect a fast-moving news topic from this week. (Select 1.)
- Rely on Claude's training knowledge alone.
- Use a Claude surface with web search/research enabled so it can pull current information.
- Ask Claude what today's date is and trust its answer.
- Wait for the next model update.
Answer: B. Current events require a live information source; training knowledge has a cutoff. A will likely produce outdated or fabricated specifics. C doesn't solve the underlying knowledge gap. D isn't a practical near-term fix.
10 · Domain 6 — Governance
An employee wants to use Claude to draft performance review language for their direct reports and have Claude also assign the final numeric ratings. (Select 1.)
- Let Claude assign ratings directly to save management time.
- Use Claude to help draft clear, well-organized review language, but keep the manager as the accountable decision-maker for ratings, watching for bias in the drafted language.
- Avoid using Claude for anything related to performance reviews.
- Have Claude assign ratings, then have the manager sign off without reviewing them.
Answer: B. This keeps a human accountable for a consequential decision about people while still using Claude productively, and flags the bias risk named in this domain's objectives. A and D hand a high-stakes, bias-sensitive decision to the model. C is an overcorrection that discards a legitimate, lower-risk use (drafting language).
11 · Domain 1 — Task Decomposition
A single prompt asks Claude to "redesign our onboarding process, write the new emails, and summarize last quarter's feedback," and the result is shallow on all three. (Select 1.)
- Ask for the same three things again in one prompt, in a different order.
- Split the request into separate steps — first the feedback summary, then the redesign, then the emails — reviewing each before moving to the next.
- Pick just one of the three tasks and drop the other two permanently.
- Ask Claude to guess which of the three matters most.
Answer: B. This is a textbook decomposition case — one broad ask covering three distinct deliverables. A doesn't change the underlying problem. C abandons legitimate work instead of restructuring the request. D offloads a decision you should make yourself.