CCAO-F Master Map: The Complete Picture

The Complete Picture — Every Course, Every Concept, How It All ConnectsCopy Anchor Link

One file to rule them all. Read this when you feel lost. Read this before the exam. Everything connects back to one philosophy — understand that, and you can reason through any scenario you've never seen.

THE PHILOSOPHY: THE ONE IDEA BEHIND EVERYTHINGCopy Anchor Link

AI is a powerful tool with no judgment of its own. You are the judgment layer. Your job is to delegate well, verify honestly, configure safely, and stay accountable.

That's it. Every single exam question is a variation of: "Did the person in this scenario exercise good judgment as the human layer?"

The wrong answers always do one of two things:

1. Trust AI blindly (reckless) — send the output without checking, upload sensitive data, let AI decide high-stakes things
2. Abandon the task (wasteful) — refuse to use AI at all when a safe path exists

The right answer always finds the safe, effective middle path that uses AI productively while keeping humans accountable.

THE EXAM IN NUMBERSCopy Anchor Link

60 questions | 120 minutes | 720/1000 to pass | $99/attempt
Criterion-referenced (you vs. standard, not vs. other students)
Result: pass/fail + scaled score + % by domain
Valid: 12 months, then free renewal assessment
Retakes: 14 days → 30 days → 90 days

Domain Weights (Priority Order for Study)Copy Anchor Link

D2  Output Evaluation & Validation    ████████████████████ 21%  ← HEAVIEST
D4  Workflow Integration & Design     ████████████████     16%
D6  Governance, Risk, Responsible Use ███████████████      15%
D1  Prompting & Task Execution        ██████████████       14%
D3  Product & Model Selection         ████████████         12%
D5  Configuration & Knowledge Mgmt   ████████████         12%
D7  Troubleshooting & Optimization   ██████████           10%

Top 3 domains = 52% of the exam. If you master D2 + D4 + D6, you're more than halfway there.

THE MASTER CONCEPT MAPCopy Anchor Link

Every course feeds into this. Here's how it all connects:

                    ┌─────────────────────────────────┐
                    │    WHAT AI ACTUALLY IS           │
                    │  (The Engine — Foundation)       │
                    │                                  │
                    │  Predicts, not looks up          │
                    │  Learned once, then froze        │
                    │  No truth-checker inside         │
                    │  Tokens = chunks                 │
                    │  Context window = only thing     │
                    │    it can see                    │
                    │  Confidence = learned style      │
                    │  Jagged ability                  │
                    │  Tools → Agent loop              │
                    │  Thinking = more prediction      │
                    └──────────────┬──────────────────┘
                                   │ explains WHY
                    ┌──────────────▼──────────────────┐
                    │         AI FLUENCY (4Ds)         │
                    │  The framework tying it together │
                    │                                  │
                    │  Delegation → decide what AI does│
                    │  Description → explain what need │
                    │  Discernment → judge output      │
                    │  Diligence → own the result      │
                    └──┬────────┬────────┬────────┬───┘
                       │        │        │        │
           ┌───────────▼─┐  ┌───▼────┐ ┌▼──────┐ └──────────────┐
           │ D1: PROMPT  │  │D2: OUT │ │D3:PROD│  D4/D5: CONFIG │
           │ & TASK EXEC │  │ EVAL   │ │& MODEL│  & WORKFLOW    │
           │             │  │        │ │SELECT │                 │
           │ AI Prompting│  │Verif.  │ │Model  │  Workflow       │
           │  in 2026    │  │Halluc. │ │ladder │  Design         │
           │             │  │Bias    │ │Cost/  │  Skills &       │
           │Just Delegate│  │When to │ │Speed/ │  Connectors     │
           │  It         │  │escalate│ │Quality│  Just Delegate  │
           └─────────────┘  └────────┘ └───────┘                 │
                                                  ┌───────────────┘
                                                  │
                                   ┌──────────────▼──────────────────┐
                                   │  D6: GOVERNANCE, RISK, RESP USE  │
                                   │                                  │
                                   │  4 Questions before AI does      │
                                   │  meaningful work                 │
                                   │  Data tiers: Green/Yellow/Red    │
                                   │  Accountability stays with YOU   │
                                   └──────────────────────────────────┘

THE LEARNING SEQUENCE (Why This Order)Copy Anchor Link

The courses build on each other in this exact logical order:

1. WHAT AI ACTUALLY IS
   ↓ (explains the machine)
2. AI FLUENCY (4Ds)
   ↓ (explains how you work WITH it)
3. JUST DELEGATE IT
   ↓ (first practical application: the delegation loop + brief)
4. AI PROMPTING IN 2026
   ↓ (the craft: briefing, context, verification habits)
5. SKILLS & CONNECTORS
   ↓ (extending the machine's reach into your real systems)
6. WORKFLOW DESIGN & DIAGNOSIS
   ↓ (team-scale: which steps AI owns, diagnosing failure)
7. GOVERNANCE, RISK & RESPONSIBLE USE
   ↓ (safety layer: what's allowed before you even start)
8. GENERAL AGENTS ON THE WEB
   (unattended work: the harness that wraps it all)

DOMAIN-BY-DOMAIN EXTRACTIONCopy Anchor Link

D1: PROMPTING & TASK EXECUTION (14%)Copy Anchor Link

Source courses: Just Delegate It, AI Prompting in 2026, AI Fluency

The Core Insight: A prompt is a briefing, not a question.

What the exam tests:

• Creating effective prompts (the Delegation Brief: Outcome, Context, Constraints, Authority, Deliverable, Verification)
• Task decomposition (break complex tasks into steps; plan-first before action)
• Iterating to improve output (brainstorm-iterate loop: context → options → feedback → expand)
• Adapting strategy by task type

The key frameworks:

Novice vs Power User:

• Novice: "Which car should I buy?"
• Power user: Upload specs/quotes/insurance → "Compare these, think hard, what are the trade-offs?"
• Gap: not cleverness — it's the briefing (files + goal + limits + exact ask)

Three retrieval modes (know which fires, because each fails differently):

1. Pretrained — fast, from training text; fails on rare/recent topics
2. Web search — live pages, tens of seconds; fails when sources are outdated/popular over reliable
3. Deep research — many searches, minutes, structured report; overkill for simple questions

Steer the mode with wording:

• "What is X" → pretrained
• "What's the latest on X / today / this week" → web search
• "Research thoroughly, produce a report with citations" → deep research

D2: OUTPUT EVALUATION & VALIDATION (21%)Copy Anchor Link

Source courses: What AI Actually Is, AI Fluency, Just Delegate It, AI Prompting in 2026

The Core Insight: AI has no truth-checker. You ARE the truth-checker. Confidence is a style, not a signal.

What the exam tests:

• Evaluate outputs for accuracy and completeness
• Identify hallucinations, inconsistencies, biases
• Apply fact-checking and validation
• Determine when human review is required
• Edit/adapt/refine outputs for intended audience
• Select appropriate output formats

The Verification Method (Identify → Trace → Challenge → Decide):

IDENTIFY   Which claims matter enough to check?
           (prices, dates, figures, citations, recommendations, anything hard to reverse)

TRACE      Open the source. Find the SENTENCE. Check the DATE.
           "A citation is not verification. Checking the citation is verification."

CHALLENGE  Could this have changed? Is AI repeating a secondary source?
           Is an assumption being stated as a fact?

DECIDE     Accept | Correct (→ Intervene) | Investigate (→ Trace again) | Reject

Hallucination — the exam's most-tested concept:

• Not a glitch — the machine working EXACTLY as built
• No internal flag between "well-supported" and "invented"
• Same confident voice for true AND false
• Confident output ≠ correct output (RLHF trained confidence as a style)
• Fix: verify against authoritative source, not against AI's self-assessment

Bias enters through:

• Training data (historical patterns)
• The prompt (unstated standards — "rank the strongest candidates" has assumptions)
• How language generates (phrasing patterns favor certain groups)

The "unverified" mark discipline:

• Include in deliverable brief: "Mark anything you could not confirm as 'unverified'"
• Count caveats in chat vs document — deliverables LOSE caveats
• Confidence + no source = don't assume it searched

Sycophancy — the silent distorter:

• "Isn't X true?" → signals the answer → trained lean supplies it
• Fix: neutral framing, rubric with specific criteria, "evaluate X and give strongest case on each side"

The sample question from official guide: Claude gives confident summary citing subsection. Best action = Verify the subsection against official text. (Not: trust confidence; not: ask Claude to rate confidence; not: just reword)

D3: PRODUCT & MODEL SELECTION (12%)Copy Anchor Link

Source courses: What AI Actually Is, AI Prompting in 2026, General Agents

The Core Insight: Match the tool to the task. The model ladder is priced according to the jagged frontier.

Model Ladder Logic (memorize logic, not names — they rotate):

TOP TIER (Opus)
  When: Deep reasoning, complex multi-part analysis, large structures held coherent
  Cost: Most expensive, slowest
  Example: Long-document analysis, hard architecture review

MID TIER (Sonnet) ← DEFAULT
  When: Most tasks — good quality/cost balance
  Cost: Moderate
  Example: Drafting, analysis, most knowledge work

SMALL/FAST TIER (Haiku)
  When: High-volume, low-depth bulk work
  Cost: Cheapest, fastest
  Example: Reformatting, quick summaries, simple classification at scale

Escalate up for DEPTH. Drop down for VOLUME. Default = mid.

The sample question from official guide: High volume short customer replies, speed + cost > deep reasoning → Use the faster, lower-cost model. (Not: always use top model; not: disable features; not: switch platforms)

Context window management (what the exam tests under D3):

When to use which Claude feature:

• Chat = thinking, drafting, designing, one-off tasks
• Projects = recurring work with same context, files, rules
• Memory = facts about you that apply everywhere
• Skills = repeatable procedures (how-to, every time)
• Connectors = access to real apps (Drive, Gmail, Slack)
• Artifacts = finished deliverables (docs, spreadsheets, code, web pages)
• Code execution = calculations that must be exact (not estimated)
• Research mode = structured report from many sources
• Web search = one current fact

D4: WORKFLOW INTEGRATION & SOLUTION DESIGN (16%)Copy Anchor Link

Source courses: Workflow Design & Diagnosis, Just Delegate It, AI Fluency, Skills & Connectors

The Core Insight: The output is not the verdict. Decide about the step (in advance, on stable grounds), not the session (after you see the result).

The Three Delegation Criteria for each step:

1. Reversibility — can we catch and undo an error before harm?
2. Stakes — what does an error actually cost?
3. Accountability — who answers for this step?

Three Step Ownership Types:

AI-APPROPRIATE: Can be undone, low stakes, someone reviews output
COLLABORATIVE:  AI produces, named person judges (most professional work)
HUMAN-RETAINED: Cannot be undone, high stakes, relationship/judgment required

The Two Mapping Errors:

• Over-delegation (halo delegation): Handing step to AI because the step BEFORE it went well. "It drafted the contract well, so it can approve clauses too." → Disaster.
• Under-delegation: Reading a bad output as proof the task is impossible. Usually a prompt problem, not a capability problem.

The Four Causes of Bad Output (Workflow Design/Diagnosis):

1. Under-specification — prompt never had what it needed (fix: add to prompt/brief)
2. Context overload — session too long, window too crowded (fix: fresh chat, summarize)
3. Wrong feature or model — right task, wrong tool tier (fix: escalate model, use code execution for exact numbers)
4. Stale configuration — saved instruction/file/skill out of date (fix: review and update Project)

The Diagnostic Sequence (cheapest check first):

1. Check the PROMPT (is it under-specified?)
2. Check SESSION LENGTH (context overload?)
3. Check FEATURE & MODEL (wrong tool?)
4. Check CONFIGURATION (stale instructions/skills?)
5. Check THE TASK (expectation mismatch — is this actually possible?)

Where fixes belong (the three homes):

• Rule → Standing instruction in Project (applies every run)
• Reference → Knowledge file in Project (AI reads when needed)
• Procedure → Skill (reusable how-to, fires on matching requests)

Workflow communication (D4.5):

• Don't oversell: "AI drafts, I verify and send"
• Always name the human gate explicitly
• Be honest about what it can and can't do

D5: CONFIGURATION & KNOWLEDGE MANAGEMENT (12%)Copy Anchor Link

Source courses: Skills & Connectors, Workflow Design & Diagnosis, Just Delegate It

The Core Insight: The context window is all the model can see. Configuration = deliberately putting the right things in the window every time, without repeating yourself.

The Persistence Stack (what persists, where):

ACCOUNT INSTRUCTIONS  → Every conversation you have
                          Write only what's true for EVERY chat

PROJECT INSTRUCTIONS  → Every chat inside that project
                          Topic-specific rules and standing instructions

PROJECT KNOWLEDGE     → Every chat inside that project
                          Files AI may read (source docs, templates, examples)

SEMANTIC MEMORY       → Cloud Cowork and chat (if enabled)
                          Facts/preferences about you across sessions

SESSION HISTORY       → This chat only
                          Replayed into context window every turn

SKILLS                → Anywhere, when request matches description
                          How-to procedures, loaded on demand

CONNECTORS            → When enabled for conversation
                          Live access to external apps

The Four Features Are One Mechanism: controlling what lands in the context window

SKILL.md Anatomy:

---
name: kebab-case-name
description: WHAT it does + WHEN to use it + EXACT PHRASES user says
---
# Body (instructions) — loaded only when description matches

The description IS the game. AI reads only the description to decide if skill fires.

Skills vs Connectors (exam loves this distinction):

• Connector = what AI can REACH (access, with scope you can narrow)
• Skill = how AI should BEHAVE (expertise, NO scope dial — reaches everything chat can reach)
• Start connectors read-only. Grant write access only after trust is earned.
• Read skills before enabling. A skill from a stranger = contract you should read.

The "need first, then tool" rule: Only learn/add a control when a job NEEDS it. Don't connect apps you don't need.

D6: GOVERNANCE, RISK & RESPONSIBLE USE (15%)Copy Anchor Link

Source course: Governance, Risk & Responsible Use

The Core Insight: Before AI does meaningful work, run four questions. The middle answer (not yes, not no) is where professional judgment lives — it requires naming a specific commitment.

The Four Questions:

1. THE CASE:    Can AI do this work?
   → Fully appropriate / Appropriate WITH REVIEW / Inappropriate
   → Use 4 delegation criteria: reversibility, consequence, human judgment, accountability
   → "Appropriate with review" = only real when you can name WHO checks WHAT and WHEN

2. THE DATA:    Can this information go in?
   → Green / Yellow (check first) / Red (not through this route)
   → Key question: Does the task need the IDENTIFIERS or only the PATTERN?
   → Route matters: "Is THIS ROUTE approved for THIS DATA and THIS PURPOSE?"

3. THE CAPABILITY: Can I turn this on?
   → Enable / Escalate / Decline
   → 5 checks: Source, Reach, Fit, Outside Content, Actions
   → Skills have NO scope dial — reach = everything the session can reach

4. THE PEOPLE:  Could this affect someone unfairly / require disclosure?
   → Decide & document / Disclose / Escalate the question
   → Review EXCLUSIONS as well as inclusions
   → Disclosure: rules first, then judgment

THE LINE ACCOUNTABILITY CANNOT CROSS:

Accountability cannot transfer to a tool. Your name on the result = your responsibility.

Data Tiers:

GREEN  → Public, aggregated, approved for broad AI use, anonymized
YELLOW → Internal-only, personal details, customer/employee IDs, confidential drafts
RED    → Credentials, regulated data (HIPAA), privileged material, secrets
Unsure? → Use the MORE sensitive tier

The Discriminator question: "Does the task need the identifiers, or only the pattern?"

• Only pattern needed → redact identifiers first (but check: pseudonymized ≠ anonymized)
• Identifiers needed → confirm the route is approved

Redaction fails two ways:

1. Partial redaction — removed name but left rare job title + date + region = still identifiable
2. Redaction breaks the task — removed information the task actually needs

Incognito/temporary chat:

• Not zero retention (30-day default on Claude)
• Not permission to put in restricted data
• Privacy control ≠ authorization

Training use by plan:

• Free/Pro/Max = may be used (user's privacy settings control this)
• Team/Enterprise/API = NOT used for training by default
• Incognito = never used for training on any plan

The sample question from official guide: PM wants to upload spreadsheet with customer names + account numbers to analyze trends. Policy restricts regulated personal data. Best action = Remove/anonymize personal identifiers before uploading. (Not: upload as-is since internal; not: instruct Claude not to retain; not: skip entirely)

When something goes wrong — first-hour procedure:

1. Stop the spread
2. Record the facts
3. Report promptly
4. State facts plainly (don't defend, don't guess)
5. Follow incident owner's instructions → DO NOT delete evidence (removes YOUR visibility, not the data)

D7: TROUBLESHOOTING & OPTIMIZATION (10%)Copy Anchor Link

Source courses: Workflow Design & Diagnosis, AI Prompting in 2026

The Core Insight: "AI failed" often means "I used the wrong approach." Diagnose before changing things.

When AI drifts — six intervention moves:

Escalate is the move people miss. "AI failed" sometimes = "I used the wrong level."

Where fixes live permanently:

• Fix that's a RULE → Standing instruction in Project
• Fix that's REFERENCE material → Knowledge file in Project
• Fix that's a PROCEDURE → Skill

Optimization habits:

• Re-test AI on your workflows every few months (jagged frontier moves)
• Audit usage quarterly (Diligence gap — policy vs. practice)
• Check if gates still run; check if Skills are still current
• When the approved path is harder than the unsafe path, reduce friction on the approved path

THE SIX ABSOLUTE RULES (What Every Correct Answer Applies)Copy Anchor Link

These are the principles behind the right answer in >80% of scenarios:

RULE 1: VERIFY BEFORE TRUSTING
  AI confidence ≠ AI accuracy.
  Check claims that matter against authoritative sources.
  A citation is not verification. Checking the citation is.

RULE 2: HUMANS STAY ACCOUNTABLE
  AI doing the work does not transfer responsibility.
  Your name on it = your judgment on it.
  Define the human gate before the run, not after.

RULE 3: MATCH TOOL TO TASK
  Right model for the job (depth vs. speed vs. volume).
  Right feature for the need (chat vs. project vs. skill vs. connector).
  Right scope for the capability (read-only before write, narrow before broad).

RULE 4: PROTECT DATA FIRST
  Classify before you act.
  Ask if the task needs the identifiers or only the pattern.
  Anonymize/redact before uploading; confirm the route is approved.
  Instructing AI "not to retain" data is a wish, not a control.

RULE 5: ESCALATE APPROPRIATELY
  Know when to involve human review, a more capable model, or a different person.
  Escalate the question WITH your reasoning attached, not a request for approval.
  Don't abandon the task when a safe path exists.

RULE 6: DON'T ABANDON THE TASK
  Skipping the analysis when anonymization would enable it = wrong answer.
  Refusing to use AI at all when a safe, effective path exists = wrong answer.
  Find the path, add the control, proceed.

THE ELIMINATION STRATEGY (For Any Exam Question)Copy Anchor Link

STEP 1: Kill the RECKLESS option
  Trusts AI blindly, skips verification, uploads sensitive data without controls,
  lets AI make high-stakes decisions alone, "send as-is since Claude was confident"
  → ELIMINATE immediately

STEP 2: Kill the WASTEFUL/ABANDONMENT option
  Refuses to use AI, skips the analysis entirely, "don't use AI for this",
  throws away useful work because output wasn't perfect
  → ELIMINATE unless the task is genuinely inappropriate

STEP 3: Between survivors, pick the one that:
  - Preserves human judgment while still using AI productively
  - Adds the right control (verification, anonymization, human gate)
  - Matches the tool to the task requirement
  - Is proportionate (not over-engineering a simple task)

Pattern recognition for the most common scenarios:

THE CORE FRAMEWORKS (Quick Reference)Copy Anchor Link

The Delegation Loop (Just Delegate It)Copy Anchor Link

DEFINE → DELEGATE → OBSERVE → INTERVENE → VERIFY → ACCEPT
You own both ends. AI owns the middle.

The Delegation Brief (6 Questions)Copy Anchor Link

Outcome:      What should exist when done?
Context:      What does AI need to know it can't know itself?
Constraints:  What limits apply?
Authority:    What may AI decide alone? What must it ask about?
Deliverable:  What form should the result take?
Verification: What will YOU check before accepting?

The 4Ds (AI Fluency)Copy Anchor Link

Delegation:   What should AI do, and what stays with me?
Description:  What does AI need to know?
Discernment:  Is the result actually good and trustworthy?
Diligence:    Is this responsible, and am I ready to own the result?

The Four Governance QuestionsCopy Anchor Link

The Case:        Can AI do this work? (3 answers)
The Data:        Can this information go in? (Green/Yellow/Red)
The Capability:  Can I turn this on? (Enable/Escalate/Decline)
The People:      Could this affect someone unfairly? (Decide/Disclose/Escalate)

The Six-Part Harness (General Agents)Copy Anchor Link

Heartbeat:    What starts a run?
Reach:        What can it read and act on?
Run-until-done: How does it keep moving toward an outcome?
State Spine:  What persists so next run ≠ zero?
Human Gate:   Where does autonomy stop or get screened?
Body:         Where does work actually execute?

The Three File Tiers (Data Custody)Copy Anchor Link

Tier 1: Scratch (task filesystem) → WIPED after task
Tier 2: Platform storage → Vendor's custody
Tier 3: Your system of record → YOUR custody
"Finished work exits the platform."

The Five Capability ChecksCopy Anchor Link

1. Source:          Who published this?
2. Reach:           What could it touch?
3. Fit:             Is that reach proportionate?
4. Outside content: Will it read untrusted material?
5. Actions:         Can it send/delete/publish/pay?
Checks 4 + 5 tell you how dangerous a mistake could become.

WHAT THE EXAM IS REALLY TESTINGCopy Anchor Link

The exam is not a knowledge quiz. It's a judgment simulation.

Every question drops you into someone's workplace and asks: "What's the most appropriate next action?"

The person who passes understands that AI is powerful AND limited, and that the human's job is to:

1. Brief it well (D1) — clear outcome, right context, constraints, defined deliverable
2. Verify the output (D2) — don't trust confidence, trace claims to sources
3. Choose the right tool (D3) — match model and feature to task requirements
4. Design the workflow correctly (D4) — decide steps in advance, name the human gate
5. Configure it properly (D5) — right instructions in the right layer, keep it current
6. Govern it responsibly (D6) — four questions, data protection, accountability
7. Fix it when it breaks (D7) — diagnose before acting, smallest fix that works

THE CONCEPTS THAT APPEAR ACROSS MULTIPLE DOMAINSCopy Anchor Link

These show up everywhere. Master them first.

1. Accountability cannot transfer to a toolCopy Anchor Link

• D2: AI doing the verification doesn't mean you're verified
• D4: Naming a human gate means a real person with real responsibility
• D6: Your name on the output = your judgment on it
• D7: You are responsible for fixing problems, not just reporting them

2. Confidence ≠ AccuracyCopy Anchor Link

• D1: Don't let confident output skip the verification step
• D2: Identify-Trace-Challenge-Decide before accepting
• D3: Asking AI to rate its own confidence is not verification
• D7: Confident wrong output is a hallucination, not a failure to try harder

3. Classify first, then actCopy Anchor Link

• D1: Choose retrieval mode before writing the prompt
• D3: Classify the task before choosing the model
• D4: Classify each step (AI-appropriate/collaborative/human-retained) before building
• D6: Classify data tier before uploading; classify use case before enabling

4. Least privilege / narrowest scopeCopy Anchor Link

• D5: Connectors — grant the smallest access the task needs
• D5: Skills — read before enabling (they have no scope dial)
• D6: Route, data, capability — all should be the minimum required
• D4: Authority — say what AI may decide, not a blanket "do whatever"

5. The middle answer requires a commitmentCopy Anchor Link

• D2: "Human will review" = meaningless without WHO/WHAT/WHEN
• D4: "Collaborative step" = only real if a named person actually judges
• D6: "Appropriate with review" = only real when the gate is defined
• D7: "Escalate" = name the specific unresolved question, not "can I do this?"

BUSINESS VOCABULARY CHEAT SHEETCopy Anchor Link

(For non-native English speakers — terms that appear in exam scenarios)

THE SAMPLE QUESTIONS DECODEDCopy Anchor Link

(From the official exam guide — these reveal the exact style)

Sample 1 (D2): Claude gives confident summary with subsection citation → compliance team

• Wrong: Send as-is (confidence doesn't matter); ask Claude to self-rate; just reword
• Right: Verify the subsection against official regulation text first
• Why: Hallucinations include specific-looking fabricated details. Confidence ≠ accuracy. Compliance = high stakes = must trace to authoritative source.

Sample 2 (D3): High-volume short customer reply drafts, speed + cost > deep reasoning

• Wrong: Always use top model; disable features; switch platforms
• Right: Use faster, lower-cost model suited to high-volume straightforward work
• Why: Model selection = match to task requirements. Reserve top model for complex reasoning, not bulk volume.

Sample 3 (D6): Spreadsheet with customer names + account numbers, analysis of trends, policy restricts regulated personal data

• Wrong: Upload as-is (internal is not permission); instruct model not to retain; skip entirely
• Right: Remove/anonymize personal identifiers before uploading, consistent with policy
• Why: The task needs the PATTERN (trends), not the IDENTIFIERS (names/accounts). Redaction enables the task safely. "Instruction not to retain" is a wish, not a control. Skipping is wasteful when a safe path exists.

THE FINAL CHECKLIST (Read the Night Before)Copy Anchor Link

THE MACHINE:
☐ It predicts, never looks up. No internal truth-checker. Confidence = style.
☐ Stateless: every response from scratch. Corrections don't stick across chats.
☐ Context window = only thing it can see. Chat history = replayed transcript.
☐ Tokens = chunks. Jagged ability. Tools → agent loop. Thinking = more prediction.

THE HUMAN LAYER:
☐ 4Ds: Delegation, Description, Discernment, Diligence
☐ Delegation Brief: Outcome, Context, Constraints, Authority, Deliverable, Verification
☐ Delegation Loop: Define → Delegate → Observe → Intervene → Verify → Accept
☐ YOU own both ends. AI owns the middle.

VERIFICATION:
☐ Identify → Trace → Challenge → Decide
☐ Accept | Correct | Investigate | Reject
☐ Accountability never transfers to the tool.
☐ Confidence ≠ accuracy. Asking AI to rate confidence = not verification.

DATA & GOVERNANCE:
☐ Four questions: Case, Data, Capability, People
☐ Three answers per question. Middle answer requires a named commitment.
☐ Defined gate = WHO checks WHAT WHEN. "Someone will review" is NOT a gate.
☐ Green/Yellow/Red. Ask: identifiers or pattern? Route approved?
☐ Incognito ≠ zero retention. Instruction to not retain ≠ control.
☐ Training: Free/Pro/Max = user controls. Team/Enterprise/API = not trained.

WORKFLOW:
☐ Decide about the STEP, not the session.
☐ Three criteria: reversibility, stakes, accountability.
☐ 4 causes of bad output: under-specification, context overload, wrong feature/model, stale config.
☐ Diagnostic sequence: prompt → session → feature/model → config → task.
☐ Three homes for fixes: rule → instruction, reference → knowledge, procedure → skill.

SKILLS & CONNECTORS:
☐ Skills = expertise (HOW). Connectors = access (REACH). Partners, not alternatives.
☐ Skill description IS the game (the only part AI reads to decide if it fires).
☐ Skills have NO scope dial. Connectors have scopes you grant and narrow.
☐ Read skills before enabling. Start connectors read-only.

CONFIGURATION:
☐ Account instructions = every chat. Projects = recurring work. Memory = about you. Skills = procedures.
☐ Put each durable fact in the NARROWEST layer that reliably applies.
☐ Review and update — stale configuration is a real failure mode.

ELIMINATION:
☐ Kill reckless (trusts AI blindly) first.
☐ Kill wasteful (abandons task) second.
☐ Pick the answer that adds the right control while still using AI productively.

THE ONE PARAGRAPH TO INTERNALIZECopy Anchor Link

The exam is built around one idea: AI is powerful, not infallible, and humans must stay in the loop at every meaningful decision. The "minimally qualified candidate" is someone who uses Claude effectively in real work — which means they brief it well, verify what it produces, choose the right feature for the task, configure it deliberately, protect data before it goes in, and own the result regardless of who produced the draft. They are not paralyzed by AI's limitations (that's abandonment) and they are not reckless about its failures (that's blind trust). They find the path that uses AI for what it does well while keeping human judgment exactly where it belongs: at the beginning (defining the task), at the end (verifying and accepting), and at every gate where a wrong action becomes hard to reverse.

Sources: Official CCAO-F Exam Guide v1.0 (July 2026) · All AgentFactory crash courses (verified Aug-Sep 2026) · Anthropic documentation (checked Sep 2026)