CCA Professional: Exam Cheatsheet & Final Review

Shadow testing — New version on real traffic, logged but never shown. Zero exposure; no real downstream signal.

Change attribution — Distinguishing model drift vs data drift vs model-update effect — each needs a different fix.

Testable criterion — A system-prompt rule you can write an eval test case for. "Be careful about security" is not testable; "Flag SQL injection and authentication bypass vulnerabilities" is.

Context strategy spectrum — Monolithic (full context always) / Progressive (append per turn) / Retrieval (RAG — fetch at query time) / Compaction (summarize old turns). Production systems almost always combine these.

Tool attribution — Every tool invocation must record: who triggered it / which permissions / against which resource / when. Logging only a service-account identity provides zero attribution.

Module 3

Alignment boundary — What trained behavior reduces (broad harm) vs what the application layer must enforce (domain policy, authorization).

Four-layer safety stack — Trained behavior / system-prompt / runtime screening / authorization. Each layer's blind spot is caught by the next.

Fail open vs fail closed — Per-guardrail decision based on the stakes of the guardrail erroring. Not a blanket policy.

Tool-call authorization — Must be deterministic, provable, and replayable. Runs before the side-effecting action.

Indirect prompt injection — Malicious instructions arriving via retrieved content or tool outputs, invisible to user-message screening.

Skill supply-chain risk — Distributable skill can carry a code-execution exploit. Mitigate with audit + runtime least-privilege sandboxing. Audit alone is insufficient.

Injection point (fairness) — Retrieval corpus / prompt framing / chosen examples / downstream routing. Four places unequal outcomes can enter.

Human-in-the-loop routing rule — Route when low-confidence AND (irreversible OR high-cost). Never by volume.

Consent fatigue — Reviewing too many items degrades review into rubber-stamping. Failure mode of routing 100% to humans.

Compliance control register — Maps obligation → technical control → named owner → evidence artifact.

Evidence artifact — Concrete, inspectable proof: signed agreement, config screen, authorization record, or log query. Not assertion.

Four named failure modes — Hallucination (confident falsehood) / Prompt injection (malicious instructions via user input or retrieved content) / Data leakage (sensitive data escapes) / Over-permissioned agents (broader tool access than task requires).

Proxy variable — A non-protected attribute (postcode, employment gap, school) that correlates with a protected attribute. Excluding the protected attribute doesn't remove the bias if a proxy variable encodes the same signal.

GDPR minimization — Architecturally: send less data rather than protect more of the same amount. Redact/pseudonymize PII before it leaves the system boundary — encryption in transit alone is insufficient.

Discernment — The reviewer skill of judging whether an output is acceptable, needs revision, or needs override. Requires a decision log as prerequisite — without a record of inputs and reasoning, there is nothing to judge against.

Decision log (three audiences) — Affected user (reason in actionable terms) / Regulator (durable queryable record) / Build team (full trace including retrieved context and routing).

Module 4

Discovery translation — Converting a preference word into a testable, bounded constraint by asking what would break the experience.

Translation table — Verbatim quote → implied constraint → architectural decision → labeled assumption with owner.

Reversal cost — What it costs to undo a decision after the system is built around it. The tradeoff element most presentations omit.

Scenario-specific demo — Built against the buyer's own workflow and data shapes. Creates confidence; generic demos create only interest.

Feedback loop — Signals → Triage → Decide → Act → Review. A signal is not yet a decision.

Governance table — Maps every production signal → trigger → Architect's action → scheduled checkpoint. Must exist before launch.

Documentation completeness — Test: can a competent Architect not in the room make a safe change after reading this? Required: decision, rejected alternatives, tradeoff, owner, evidence, and labeled assumptions.

Entry-point-responsibility map — Documents which Claude entry point owns which task and why in a multi-platform deployment.

Outcome document — Six fields: use case + scope / metric before / metric after (same definition) / auditable control / measurement owner / reuse potential.

Module 5

Champion-per-department rollout — Enable one champion per team first, capture their solved configuration, seed adoption in batches.

Shared configuration — CLAUDE.md + tool/MCP config + permission posture in version control; everyone starts from this baseline.

Skills distribution mechanisms — Org-provisioned (reach, no rollback) / plugin (versioned, rollback) / project Skill (repo-scoped) / API Skill (pinned).

Spend posture — Model defaults + allowlists + effort guidance + spend/rate/per-user caps — configured before the first bill.

Verification checklist — Correctness / security / maintainability / human understanding. Human understanding can never be automated.

Diligence — Taking responsibility for verifying and vouching for AI-generated output — catches judgment erosion.

Runbook — Symptom → cause → action → escalation. The cause layer prevents wrong-action pattern-matching.

Escalation path — Named definition of who handles what and when an issue leaves the team.

15-Item Final Checklist

Work through each item. If any takes more than 10 seconds, re-read the corresponding module lesson.

• Can recite the four AI properties → design consequence mapping without hesitation, including which one maps to evals vs. human-in-the-loop
• Can explain why Claude Code is disqualified as a backend the instant "multi-user" or "customer-facing" appears in a brief
• Know the eval grading ladder (code → model → human) and can state why an uncalibrated judge is worse than no automated grade
• Can name which reliability control (retry / circuit breaker / fallback) belongs at which layer of the stack
• Can state the training-time vs inference-time boundary and give an example of a rule Claude was "never given"
• Know the four-layer safety stack and each layer's specific blind spot, in order; can extend to the five-layer stack and identify which layers are deterministic vs probabilistic
• Can name the four named failure modes (hallucination / prompt injection / data leakage / over-permissioned agents) and the correct fix for each
• Know the system-prompt four-component structure (role → testable criteria → boundary statements → output format) and can distinguish testable from non-testable criteria
• Can explain why tool-call authorization is "almost always deterministic" while input/output screening can be model-based
• Know the human-review routing rule (confidence + reversibility + cost) and can spot "route by volume" as the wrong answer on sight
• Can name all three fields a compliance control register requires (control, owner, evidence artifact)
• Know the four discovery question categories and can invert a preference word ("seamless") into a testable constraint on the spot
• Can list all three elements of a tradeoff presentation and explain why reversal cost is the one that changes the meeting
• Know the outcome document's six fields, and which two become load-bearing under a strict regulatory obligation
• Can match all four Skills distribution mechanisms to their reach/rollback tradeoff without looking it up
• Know the four dimensions of a verification checklist for AI-generated code, and which one can never be automated away
• Reviewed the Trap Pattern Library once, end to end, within 24 hours of the exam

What to Do in the Exam Room

First 5 minutes: skim all 63 questions. Flag the ones you want to return to. Don't get stuck on question 3 when there are 60 more.

Per question:

1. Read the question stem first
2. Before reading options, form your own answer
3. Check your answer against the options
4. If your answer doesn't appear, apply the Master Pattern: which option is verified vs assumed?

Multi-select questions: find both correct answers before confirming. The first plausible-sounding answer is often a trap to make you stop looking.

Scenario-matching questions: the option set is small (3–4 choices). Map each scenario to its distinguishing characteristic: step structure (workflow vs autonomous), ownership (internal vs cross-org), reuse (one app vs many).

Time pace: 63 questions in 120 minutes = ~1:54 per question. Check your position at question 21 (40 min) and question 42 (80 min). Adjust pace if behind.

Practice the full 63-question exam under timed conditions at /quiz/cca-professional before sitting the real exam.