CCA-P start here · Mind maps

CCA-P mind maps

All 38 guide lines on one page. Each map says, for the situations the exam likes, which answer wins, including the row where the runner-up wins. Read these the week before the exam.

Domain 1: Solution Design & Architecture 17%

1.1 · Translate business problems into Claude-based AI solutions

Rule: If a part of the problem is exact (a lookup, a rule, a sum), give it to code; if it is language or judgement, give it to Claude, and stop at the simplest design that meets every stated constraint.
When the stem says…PickWhy
Part of the task is an exact lookup or calculationPlain code, a query or a toolExact, cheap and testable, with no model guesswork
The task is reading messy text and making a judgementA Claude call with a clear promptThis is where a language model adds value
The answer depends on private or changing documentsClaude plus retrieval (an augmented LLM)The model needs the facts at request time
The decision is high-impact or regulatedClaude drafts, a person approvesKeeps accountability with a person
The steps cannot be known in advanceAn agentOnly then does the extra autonomy pay for itself

Study and practise 1.1 →

1.2 · Design end-to-end architectures (input → processing → output → feedback loops)

Rule: If quality drifts unseen, add the feedback loop; if bad data gets in, validate input; if bad formats get out, validate output in code.
When the stem says…PickWhy
Quality drifted after launch and nobody noticedAdd the feedback loop and monitoringNothing was measuring quality in production
Blank or unsupported files cause invented answersValidate at the input stageCheaper to reject early than to repair later
A downstream system breaks on bad formatsValidate output against a schema in codeCatches errors before delivery
Users fix outputs by hand every dayCapture the corrections as labelled dataTurns daily work into eval cases
One known case fails because the prompt is plainly wrongFix the prompt, then add the case to the evalsA direct defect is fixed directly; the loop stops it coming back

Study and practise 1.2 →

1.3 · Select appropriate architectural patterns (workflow, agentic, augmented LLM)

Rule: Pick the least autonomy that solves the problem: one answer from documents gets an augmented LLM, fixed steps get a workflow, and open-ended work gets an agent.
When the stem says…PickWhy
One question, answered from documentsAugmented LLM with retrievalThere is no sequence of steps to manage
Every item goes through the same known stepsWorkflow: prompt chainingA fixed order is predictable and testable
Inputs fall into distinct types that need different handlingWorkflow: routingEach type gets its own tuned prompt or model
A draft must meet clear criteria, and critique helpsWorkflow: evaluator-optimizerRepeated refinement against a checkable standard
The next step depends on what was just foundAgentOnly a model-directed loop can change the path as it goes

Study and practise 1.3 →

1.4 · Design multi-agent systems and orchestration strategies

Rule: If the work splits into independent or specialist parts, use a coordinator with scoped subagents and full briefs; if the steps depend on each other, keep one agent with good tools.
When the stem says…PickWhy
One user goal, a handful of tools, steps that depend on each otherA single agentCoordination would add cost with no gain
Many independent research threadsCoordinator with parallel subagentsBreadth runs in parallel, in separate contexts
One part needs permissions the others must not haveA separate specialist subagentIsolates tools and access by role
Subagents return inconsistent or repetitive resultsFuller briefs plus a coordinator checkSubagents know only what they are told

Study and practise 1.4 →

1.5 · Apply decomposition techniques for complex problem solving

Rule: If the steps are known, chain focused prompts with a check between each; if one input is too big to review well, do per-item passes and then an integration pass; if the steps depend on findings, decompose adaptively.
When the stem says…PickWhy
One prompt does extraction, analysis and writing, and quality is unevenA prompt chain with checks between stepsEach step gets full attention and can be tested
Reviewing a forty-file change misses issuesPer-file passes, then an integration passDepth on each file plus a cross-file view
The plan depends on what the first findings showAdaptive decompositionA fixed chain cannot follow new leads
A simple task is already done well by one promptKeep the single promptExtra steps would only add latency and cost

Study and practise 1.5 →

1.6 · Align solutions to business value pillars (efficiency, transformation, productivity, cost, performance SLAs)

Rule: If the sponsor wants lower cost, pick the cheapest design that meets the quality floor; if they want an SLA, design for the latency target; if they want something new, judge it by adoption; and always measure that pillar against a baseline.
When the stem says…PickWhy
The goal is a lower cost per ticketThe cheapest configuration that meets the quality floorServes the cost pillar directly
Answers must arrive within an agreed timeA fast model and streaming on the live pathMeets the performance SLA
The goal is a service customers could not get beforeA more capable design, judged by adoption and revenueTransformation can justify a higher cost
Analysts want to handle more cases each dayAssisted drafting, with a person finishingProductivity: more output per person
The sponsor's stated priority is the highest possible accuracyThe most accurate option, even at higher costHere the expensive option serves the right pillar

Study and practise 1.6 →

Domain 2: Claude Models, Prompting & Context Engineering 13%

2.1 · Select appropriate Claude models based on trade-offs

Rule: If a smaller model passes your eval, use it; if only some requests are hard, route just those to a capable model; if nobody is waiting for the answer, batch it.
When the stem says…PickWhy
Millions of simple, well-defined items a dayA smaller, faster model validated on an evalMeets quality at a fraction of the cost
Hard multi-step reasoning or complex agent workThe most capable modelSmaller models fail the quality bar here
Traffic is a mix of easy and hard requestsRoute by difficultyCheap for most requests, capable where needed
Results are needed by tomorrow, not instantlyBatch processingLower price, and latency does not matter
The small model fails the eval on important edge casesMove up a tier, or route only those cases upThe quality bar comes before cost

Study and practise 2.1 →

2.2 · Design system prompts, templates, and guardrails

Rule: If a rule is about style or scope, put it in the system prompt with its reason; if it must never be broken, also enforce it in code; and if many prompts share it, keep it in one versioned template.
When the stem says…PickWhy
Instructions hidden in uploaded content change behaviourTag untrusted content as data, and check actions in codeTwo layers against prompt injection
Teams copy and edit the same prompt, and versions driftOne versioned template with variablesA single reviewed source gives consistent behaviour
Output must always be valid JSON for a parserValidate against a schema in codeA request in the prompt can still fail
The assistant drifts into off-topic adviceClear scope and a hand-off path in the system promptSoft scope rules are well handled in the prompt
A rule must never be broken, such as a refund limitEnforce it in the tool, not just the promptCode is deterministic; prompts are not

Study and practise 2.2 →

2.3 · Apply prompt engineering techniques (zero-shot, few-shot, chain-of-thought)

Rule: If the task is clear and passes, stay zero-shot; if format or borderline cases wobble, add varied examples; if the format is right but the logic is wrong, let Claude reason before it answers.
When the stem says…PickWhy
A clear, simple task that already passesZero-shotAny extra technique adds cost without benefit
Output format or tone varies between runsFew-shot examplesExamples show the exact target
Borderline cases are labelled inconsistentlyFew-shot examples of those borderline casesExamples show where the line falls
The format is right but multi-step decisions are wrongChain-of-thought or extended thinkingThe failure is reasoning, not format
A quick lookup with a tight latency budgetNo chain-of-thoughtReasoning would add delay for no gain

Study and practise 2.3 →

2.4 · Optimize context windows and manage token usage

Rule: If context grows with history, summarise old turns and pin exact facts; if tools return bulk, trim it at the source; if documents are large, retrieve the relevant parts, and put any long document first and the question last.
When the stem says…PickWhy
Cost rises with conversation length because the full history is resentSummarise old turns and pin key factsSmaller context, with exact values kept
A tool returns 200 fields and the task uses fiveTrim tool output to the needed fieldsLess noise and fewer tokens on every call
The whole policy library is pasted into every promptRetrieve the relevant sectionsSends only what the question needs
A short, stable reference text is needed on every requestKeep it in context and cache itRetrieval would add a step for no saving
Answers miss a detail in a long documentDocument first, question lastHelps the model use long inputs

Study and practise 2.4 →

2.5 · Implement prompt reuse strategies (caching, modular prompts, Skills)

Rule: If the same long content goes with every request, put it first and cache it; if many prompts share rules, build them from modules; if expertise is needed only sometimes, package it as a Skill.
When the stem says…PickWhy
The same long system prompt and policy go with every request; cost and latency matterStatic content first, then prompt cachingThe repeated prefix is read from the cache
Many prompt variants share rules that keep drifting apartModular, versioned prompt componentsOne fix updates every prompt
Many specialist procedures, each needed only now and thenAgent SkillsLoaded on demand, not on every request
Each request is one-off, or its start changes every timeNo cachingNothing repeats, so the cache would not be reused
Caching is on but the hit rate is near zeroMove variable content after the static prefixSomething early in the prompt is changing

Study and practise 2.5 →

Domain 3: Integration 19%

3.1 · Evaluate tool/agent configuration for capability bloat

Rule: If the role never uses a capability, remove it from both the tool list and the account; if it is rarely used but high-impact, keep it behind human approval.
When the stem says…PickWhy
The role never uses a tool the agent hasRemove the toolEliminates the risk entirely
The role needs the tool, but rarely, and the action is high-impactKeep it behind human approvalRemoving it would block real work
The role needs a tool, but only part of itReplace with a narrower toolKeeps the job possible with less power
The agent runs under a shared or admin accountGive it its own scoped identityThe permission layer is the backstop if a tool slips through
Auditors need a record of what happenedAdd logging as wellLogging supports, it never replaces, least privilege

Study and practise 3.1 →

3.2 · Analyze authentication and authorization requirements to identify security gaps

Rule: If users can reach data they could not open themselves, act with their delegated, scoped token and filter retrieval by their access; if users are not signed in at all, fix authentication first.
When the stem says…PickWhy
The agent acts for individual users in systems that already have per-user permissionsDelegated, user-scoped tokenThe system enforces what that user may do
Users see answers from documents they could not open themselvesFilter retrieval by each chunk's access listRestricted text never reaches the model
Access rules are coarse and match teams cleanly (say, one index per legal entity)Separate indexes per groupSimpler, and enough when permissions follow the split
A background job with no user behind it (nightly batch)Its own narrowly scoped service identityThere is no user to delegate from, so least privilege applies to the service
Users are not signed in at allFix authentication firstAuthorization needs a known identity to work from

Study and practise 3.2 →

3.3 · Evaluate accuracy-latency trade-offs and justify configuration decisions

Rule: If the SLA is tight and only some requests are hard, route those to the heavy path; if a check's result is used later, move it off the live path.
When the stem says…PickWhy
Most requests are easy, a few are hard, and the SLA is tightRoute: fast path by default, heavy path for hard casesKeeps p95 low and accuracy where it matters
A check improves accuracy but the result is used laterVerify asynchronously, off the live pathAccuracy gain without user-facing delay
A person reads a long answer and complains it feels slowStream the outputPerceived speed improves; nothing else changes
Every request is high-stakes and the SLA is looseThe heavier, more accurate configuration everywhereLatency has room, so take the accuracy
A long, identical prefix is sent on every callPrompt cachingLower time to first token at no accuracy cost

Study and practise 3.3 →

3.4 · Analyze observability challenges and select monitoring strategies at scale

Rule: If you can't tell which step failed, trace every request under one ID; if spend or slowness hides in totals, measure per request and per step with percentiles; if quality may drift, score a live sample.
When the stem says…PickWhy
Can't tell which step in a multi-step system caused a bad answerEnd-to-end tracing with one request IDShows each step's input and output in context
Spend rose but volume didn't, or some users are very slowPer-request, per-step token, cost and latency percentilesFinds the expensive or slow path that totals and averages hide
Quality may be drifting, but nothing errorsSampled quality evals with alertsQuality is invisible to system metrics
The failing step is already known and needs detailRicher logging on that stepTargeted detail is cheaper than logging everything

Study and practise 3.4 →

3.5 · Design a RAG pipeline with appropriate chunking and indexing strategies

Rule: If ideas are split across chunks, chunk by the document's structure with overlap; if chunks lose their context, add metadata and contextual notes; if sources change, re-index.
When the stem says…PickWhy
A clause or table is split across two chunksStructure-aware chunking with overlapKeeps each idea in one retrievable piece
Chunks are correct text but from the wrong version, region or dateMetadata plus filters, or contextual retrievalThe chunk alone doesn't say where it belongs
Short, unstructured documents such as chat messages or notesSimple fixed-size or whole-document chunksLittle structure to exploit; simplicity wins
Answers became wrong right after a document refreshCheck the re-index and embedding modelStale or mismatched index, not the model
Matches are precise but answers lack surrounding detailRetrieve small chunks, pass the parent sectionPrecision for search, context for the answer

Study and practise 3.5 →

3.6 · Apply retrieval strategies matched to data shape and query pattern

Rule: If queries mix exact codes with descriptions, use hybrid search; if the right result ranks too low, rerank; if the question needs totals over tables, give Claude a query tool.
When the stem says…PickWhy
Users describe problems in their own wordsVector (semantic) searchMatches meaning across different wording
Queries contain exact codes, IDs or names, mixed with descriptionsHybrid: vector plus BM25 keywordExact terms and meaning both count
Queries contain only exact identifiers, such as a part-number lookupKeyword search or a direct lookupNo meaning to match; exact is enough
The right passage is retrieved but ranked too lowAdd a rerankerRe-scores candidates for precision
Questions need totals, counts or trends over tablesA query tool over the databaseExact computation over every row

Study and practise 3.6 →

3.7 · Evaluate connection protocols and select the appropriate integration mechanism (MCP, API/CLI, agent-to-agent)

Rule: If many AI clients need the same capability, build an MCP server; if one app makes a fixed call, call the API directly; if another party's agent runs the whole task, delegate agent-to-agent.
When the stem says…PickWhy
The same tool is needed by several AI clients or teamsAn MCP serverBuild once, reuse everywhere, govern centrally
One backend calls a known service in a fixed wayDirect API callFewest moving parts; nothing to reuse
A coding agent with a shell needs a well-known toolThe existing CLIThe model already knows it; no server needed
A partner's agent handles a multi-step task with its own private systemsAgent-to-agentYou hand over a goal, not individual calls
A partner offers simple, documented endpoints and no agentDirect API or an MCP wrapperThere is no agent to delegate to

Study and practise 3.7 →

3.8 · Evaluate progressive discovery vs. monolithic context strategy

Rule: If content is large and each task uses a slice, discover it progressively with Skills, tool search or resources; if it is small, stable and always needed, load it up front and cache it.
When the stem says…PickWhy
Hundreds of tools, each task uses a few, and wrong tools get pickedTool search (deferred tool loading)Only relevant definitions reach the model
Long procedures, each needed only for certain tasksSkillsInstructions load only when the task calls for them
Small, stable content needed on nearly every requestMonolithic, with prompt cachingNo lookup step; caching makes it cheap
Large reference data read occasionallyMCP resources or file browsingFetched on demand instead of preloaded

Study and practise 3.8 →

Domain 4: Evaluation, Testing & Optimization 16%

4.1 · Define evaluation metrics (accuracy, latency, cost, safety, security)

Rule: If you cannot say what “good” is as a number, define the metric and target before changing anything; if a stem mentions perceived speed, think time to first token, and if it mentions outside content, add a security metric.
When the stem says…PickWhy
Streamed chat “feels slow” though average time meets targetTime to first token and p95 latencyUsers feel the wait for the first words and remember the slow tail
A nightly job nobody waits onThroughput and cost per taskFirst-token speed does not matter when no one is watching
An agent makes many calls per taskSuccess rate and cost per completed taskPer-call numbers hide retries and loops
Open-ended answers with many good wordingsRubric score from a judge or a personExact match would mark good paraphrases wrong
The system reads content from outside the companyAdd injection success rate and leakage rateAccuracy metrics say nothing about attacks

Study and practise 4.1 →

4.2 · Design evaluation datasets and test frameworks using mixed methodologies

Rule: If a check is objective, grade it with code; if it is open-ended and high-volume, use a rubric judge calibrated on human labels; if it is high-stakes or low-volume, have a person review it.
When the stem says…PickWhy
Output must be valid JSON with fixed fieldsCode checksExact, instant and free
Thousands of open-ended outputs a weekLLM-as-judge with a rubric, calibrated on human labelsScales and still grades meaning
Errors are costly (medical, legal)Human expert review on top of automated checksThe stakes justify the cost
The judge disagrees with expertsFix the rubric and recalibrate before using itAn uncalibrated judge measures the wrong thing
Low volume and rare changesHuman review alone can be enoughAutomation is not worth building yet

Study and practise 4.2 →

4.3 · Conduct A/B testing and iterative improvements

Rule: If a change has not passed the offline eval, run it there first; if the question is business impact, A/B test one change on a random share of traffic with guardrails agreed up front.
When the stem says…PickWhy
A new prompt looked better on a few examplesRun the full offline eval firstAnecdotes miss regressions
Offline eval passed; the question is business impactA/B test on a random share of live trafficOnly real users show conversions or resolutions
Showing users a worse answer is unacceptableShadow testLive inputs, no user exposure
Prompt and model both changed at onceTest them separatelyOtherwise the cause is unknown
Traffic is too low for an A/B result in reasonable timeOffline eval, then staged rollout with close monitoringAn A/B test would never reach a clear answer

Study and practise 4.3 →

4.4 · Diagnose system issues (prompt failure, hallucinations, model mismatch)

Rule: If answers are wrong, look at the inputs and retrieved context first, then the prompt, then the model; if the fact is missing, fix retrieval, and if it is present but ignored, fix the prompt.
When the stem says…PickWhy
Confident wrong answers right after a document refresh; model unchangedCheck retrieval and indexingThe data changed, the model did not
Similar requests get different formats or handlingFix the prompt (clear rules, examples)Instructions are ambiguous
The right passage was retrieved but the answer contradicts itGround the answer: quotes, citations, allow “I don't know”Context is fine; the instruction to use it is weak
Context right, prompt clear, multi-step reasoning still failsTry a more capable modelUpstream causes are ruled out
A simple task is accurate but expensiveTry a smaller, faster modelMismatch the other way: overpaying

Study and practise 4.4 →

4.5 · Optimize token usage, latency, and cost-performance trade-offs

Rule: If nobody waits for the result, batch it; if the same prefix repeats, cache it; if independent steps run in series, parallelise them; and if quality is not re-checked, do not ship the optimisation.
When the stem says…PickWhy
A large job nobody waits onMessage Batches API (plus a smaller model if the eval holds)About half price; latency does not matter
The same long instructions on every requestPrompt cachingThe prefix is paid in full once, then read cheaply
Independent steps run one after anotherParallel callsTotal wait becomes the longest step
Chat feels slow and answers are longStreaming and shorter outputsFirst words sooner, less to generate
A user needs the answer within secondsReal-time calls with caching or a smaller model, not batchBatch can take hours

Study and practise 4.5 →

4.6 · Monitor system performance using logging and observability tools

Rule: If you cannot tell which change caused a drop, log prompt and model versions per request; if errors look normal but users complain, score sampled outputs for quality.
When the stem says…PickWhy
Quality dropped after a release; cause unknownGroup quality by prompt and model versionShows which change caused the step
An agent is slow and nobody knows which stepPer-step tracingFinds the slow step directly
Cost rising while traffic is flatTokens per request and cache hit ratePoints to bigger prompts or a broken cache
Wrong answers but error rate normalSampled online quality scoringBad content still returns success
A severe harmful output is live right nowRoll back first, then investigate with the logsStopping harm comes before diagnosis

Study and practise 4.6 →

Domain 5: Governance, Safety & Risk Management 14%

5.1 · Implement guardrails and safety controls

Rule: If a rule must always hold, enforce it in code or permissions; if it is a soft preference, guide it in the prompt; and assume untrusted content will sometimes inject, so limit what the tools can do.
When the stem says…PickWhy
A rule that must always hold (a refund ceiling, approved recipients)Enforce it in tool code or permissionsDeterministic; a prompt is followed most of the time, not always
Untrusted content reaches the model (web pages, emails, uploads)Treat it as data and limit what the tools can doSome injection will get through, so limit the damage it can cause
A tone, style or scope preference that does little harm if missedGuide it in the system promptHere the prompt wins: code enforcement would be heavy for a soft rule
Sensitive data must never appear in responsesKeep it out of the context, and redact output as a backstopData the model never sees cannot leak
Cost or volume could spiralRate limits, loop caps and budget limits in codeA hard ceiling stops runaway behaviour

Study and practise 5.1 →

5.2 · Identify risks, limitations, and failure modes of LLM systems

Rule: If the output must be exact or current, get it from a tool or code; if it must be grounded, require sources; if an agent can loop, cap it in code.
When the stem says…PickWhy
Exact maths over many figures is sometimes wrongA calculation tool or codeAsking for precision or step-by-step reasoning makes errors rarer, not impossible
Answers about recent events or today's prices are out of dateRetrieval or a live-data toolThe model's knowledge stops at its training cutoff
Answers contain facts that are not in the documentsGround in retrieved text, require citations, allow “I don't know”Targets hallucination at its cause
The judgement, not the arithmetic, is what goes wrongChain-of-thought or extended thinkingHere the runner-up wins: a calculator cannot fix a wrong judgement
An agent repeats tool calls for hoursIteration and budget caps in codeStops runaway cost whatever the model decides

Study and practise 5.2 →

5.3 · Apply human-in-the-loop validation strategies

Rule: If an action is irreversible or high-impact, require approval first; if a case fails a check, send it to review; if it is low-risk, automate it and audit a random sample.
When the stem says…PickWhy
The action cannot be undone or is high-valueHuman approval before it executesA later audit cannot reverse the harm
High volume, low impact, mostly correctAutomate, and audit a random sampleReviewing everything would not scale
The case failed a check or lacks evidenceSend that case to a reviewerFocuses human time where errors are likely
Reviewers approve 99% of items in secondsRedesign the review: smaller risk-based queue, evidence shown, spot checksRubber-stamping means the control has stopped working
Every output carries legal or safety weightHuman review of every itemHere the runner-up wins: the risk justifies the cost

Study and practise 5.3 →

5.4 · Ensure compliance with regulations (e.g., GDPR, HIPAA, FedRAMP)

Rule: If the data is EU personal data, minimise it and control purpose, region, retention and erasure; if it is US health data, use a BAA-covered deployment with minimum necessary PHI and audit logs; if it is US federal work, use a FedRAMP-authorised deployment.
When the stem says…PickWhy
EU customers' personal dataMinimise, keep to the stated purpose, honour access and erasure, control region and retentionGDPR's core demands
Patient records at a US hospitalA deployment covered by a BAA, minimum necessary PHI, access control, audit logsHIPAA's core demands
A US federal agency workloadA deployment with the appropriate FedRAMP authorisationFederal use requires the authorisation
A person asks for their data to be erasedErase it everywhere, including logs and eval copiesErasure covers every copy, not just the main database
The task works on aggregate or properly de-identified dataUse that data instead of raw recordsHere the lighter path wins: data that is not personal or PHI carries far fewer obligations

Study and practise 5.4 →

5.5 · Address ethical AI considerations (bias, fairness, transparency)

Rule: If fairness is in doubt, measure outcomes across groups and hunt for proxies; if a decision is consequential, a named person owns it; if people meet the AI, tell them and offer a person.
When the stem says…PickWhy
Leadership worries the system may be biasedMeasure outcomes across groups on a representative test setEvidence first; you cannot fix what you have not measured
A protected attribute was removed but outcomes still differLook for proxies, then mask and re-measureOther fields can stand in for the attribute
People do not realise a reply was AI-generatedDisclose AI use, say who decides, offer a personTransparency builds trust and prevents false beliefs
The decision affects someone's job, credit or careA named person makes and owns the decisionAccountability cannot sit with a model
A low-stakes internal draft, such as meeting notesLight disclosure; no group-outcome studyHere the lighter option wins: little to measure and little harm

Study and practise 5.5 →

Domain 6: Stakeholder Communication & Lifecycle Management 14%

6.1 · Conduct structured discovery and requirement gathering

Rule: If success is not yet defined, run discovery and agree a measurable target first; if success is defined but the data is unchecked, assess the data and prototype; if both are settled, move on to design.
When the stem says…PickWhy
A sponsor asks for a technology (“a chatbot”, “agents”) with no defined outcomeDiscovery: goal, users, measurable success criteriaThe request is a solution, not a problem
Stakeholders want different thingsBring them together to agree one measurable outcome firstDesigning for competing goals satisfies no one
Success is defined, but nobody has checked the dataAssess the data, then prototype on a real sampleMissing or stale data is the most common project killer
Goal, data and constraints are clear and signed offMove on to designHere more discovery would only delay the project

Study and practise 6.1 →

6.2 · Communicate architectural decisions and trade-offs

Rule: If the listener is an executive, speak in value, cost and risk; if they are engineers, speak in design detail; if someone else owns the decision, give options, trade-offs and your recommendation, then record it in an ADR.
When the stem says…PickWhy
An executive questions the cost of the designCost per correct outcome, with eval numbers and optionsSpeaks to the decision they own
A board or sponsor must decide in a short meetingValue, risk, cost and a recommendation first; detail on requestThey need what the decision depends on
Engineers will build and run itComponent and interface detail, failure handlingThey need the how, not just the why
A decision is likely to be questioned again laterWrite an ADRKeeps the context and reasons after people move on
Only one option meets a hard constraint (data must stay in region)State the constraint and the single optionHere inventing alternatives would waste time

Study and practise 6.2 →

6.3 · Manage stakeholder feedback loops and expectation alignment (including SLAs)

Rule: If stakeholders expect perfection, agree a measured error target plus error handling; if targets are vague, make them measurable SLAs; if scope grows, assess the impact and agree a revised plan openly.
When the stem says…PickWhy
Stakeholders expect 100% accuracyA measured target plus error handling, shown with eval data and the human baselinePerfection is not achievable; a managed error rate is
Sponsor and team disagree whether it is “fast enough”Agree measurable SLAs and track themA vague target cannot settle the argument
A new group or feature is requested mid-projectAssess impact on cost, time and quality, then agree a revised planSilent absorption breaks timelines and quality
Users complain informally and nothing changesA regular review that turns feedback into eval casesCloses the loop
Errors would cause serious harm (medication doses)Human check of every output, even with less automationHere the stricter option wins: error handling must cover every case

Study and practise 6.3 →

6.4 · Document architectures and provide implementation guidance

Rule: If a team must change the system, give it versioned prompts and the eval suite; if it must run the system, give it runbooks and named owners; if it must understand the system, give it the architecture and ADRs.
When the stem says…PickWhy
The new team fears changing prompts without knowing the effectThe eval suite tied to versioned promptsProves a change helps, and allows rollback
On-call staff have never handled this system's incidentsRunbooks with clear stepsNobody should rely on memory under pressure
Nobody knows who owns an integrationAn ownership tableIncidents stall without a named owner
The new team asks why a design choice was madeADRsRecord the context and the rejected options
A two-week prototype that will be thrown awayA short summary of findingsHere the light option wins: a full pack would be wasted effort

Study and practise 6.4 →

6.5 · Support lifecycle phases (discovery, design, handoff, monitoring, iteration)

Rule: If a new model version arrives, test it on the eval suite and roll it out in stages; if quality drifts with no code change, look at data and usage and add the new cases to the eval suite; if a version is retiring, migrate early.
When the stem says…PickWhy
A newer model version is availableEval suite on it, compare quality and cost, then a staged rolloutNewer is not automatically better for your task
Quality slowly falls with no code or prompt changeLook at data and usage drift, then iterateThe world moved, not the code
The current model version will be retired in some monthsTest the new version now and migrate in stages before the dateAvoids a rushed, untested switch
A production failure was foundFix it and add it to the eval suiteStops the same failure coming back
The new version is better and cheaper on every eval metricStage the rollout quicklyHere moving fast wins, but still in stages

Study and practise 6.5 →

Domain 7: Developer Productivity & Operational Enablement 7%

7.1 · Configure Claude tools and environments for teams (e.g., Claude Code)

Rule: If a rule must hold for everyone and nobody may loosen it, use managed settings; if it is the team's setup, commit it to the repo; if it must always run or be blocked, use a hook or permission rule, not CLAUDE.md.
When the stem says…PickWhy
An organisation-wide rule nobody may loosenManaged settingsHighest precedence; users cannot override
A team convention, such as the test command or styleProject CLAUDE.mdShared guidance that travels with the repo
Something must happen or be blocked every timeHook or permission rule in .claude/settings.jsonEnforced, not just suggested
The team shares an MCP server that needs a token.mcp.json with an environment-variable referenceShared setup, no secret in git
One repository needs a restriction its own team ownsDeny rule in that project's settingsManaged settings are for organisation policy, not one team's choice

Study and practise 7.1 →

7.2 · Improve developer workflows using AI-assisted tooling

Rule: If the team wants the same check on every change, run Claude in CI with structured output; if someone asks whether it pays off, measure cycle time and defects, and always keep humans approving.
When the stem says…PickWhy
A consistent automated review on every pull requestClaude Code in CI, non-interactive, structured outputRuns the same way every time without relying on people
A developer wants help before they pushLocal Claude Code with a shared review commandFast feedback for one person
Leadership asks if it is worth the costCycle time and escaped defects before and afterOutcomes, not usage
Hundreds of files need the same library upgradeClaude-driven migration in small batches, tests on eachRepetitive and checkable
Someone suggests auto-merging what Claude approvesKeep human approvalThe first pass is not the decision

Study and practise 7.2 →

7.3 · Support debugging and operational issue resolution

Rule: If Claude is investigating, give it read-only access to logs, metrics and runbooks; if it proposes a change to production, a human approves and applies it; if a bug is intermittent, find the root cause before fixing.
When the stem says…PickWhy
On-call wants help triaging incidentsRead-only MCP access to logs, metrics and runbooksFast investigation with no production risk
Claude proposes a production changeEngineer approves and applies it through the change processHigh-impact actions need a human and a record
A test fails intermittentlyReproduce, find the root cause, then fixRetries hide the bug
A low-risk, well-tested runbook step runs many times a weekConsider approved automation for that step onlyApproval for every repeat adds little safety
Engineers paste logs into a chat by handConnect the sources through MCPFaster and complete, with less copying

Study and practise 7.3 →

CCA-P start here · Guide walkthrough · Trap gym