Curriculum
7 domains · 38 lessons mapped 1:1 to official CCAR-P objectives. Deep lesson content lands in Phase 2.
Domain 1 · 17%
Solution Design & Architecture
Translate business problems into Claude solutions, design end-to-end architectures, choose patterns, and align to value pillars.
- 1.1
Translate business problems into Claude-based AI solutions
Map stakeholder goals, constraints, owners, and success metrics to a Claude-shaped scope — decide where language judgment beats deterministic software before picking models, tools, or RAG.
- 1.2
Design end-to-end architectures (input → processing → output → feedback loops)
Design the full path from intake through processing and delivery, plus the feedback loop that captures outcomes, failures, and human review for continuous improvement.
- 1.3
Select appropriate architectural patterns (workflow, agentic, augmented LLM)
Choose workflow, agentic, or augmented-LLM patterns from task structure, control needs, latency, and unpredictability — not from buzzwords.
- 1.4
Design multi-agent systems and orchestration strategies
Split roles, pass context explicitly, and orchestrate specialists through a coordinator — no inherited memory, no peer mesh that hides accountability.
- 1.5
Apply decomposition techniques for complex problem solving
Break complex work into units that fit model attention, tool scope, and verification — adaptive when structure is unknown, fixed when dependencies are clear.
- 1.6
Align solutions to business value pillars (efficiency, transformation, productivity, cost, performance SLAs)
Tie every architecture choice to named pillars — efficiency, transformation, productivity, cost, and performance SLAs — with measurable trade-offs stakeholders accepted.
Domain 2 · 13%
Claude Models, Prompting & Context Engineering
Select models, design prompts and guardrails, engineer context, and reuse prompts efficiently.
- 2.1
Select appropriate Claude models based on trade-offs
Choose relative model tiers by task difficulty and risk, weighing latency and unit cost at expected volume — and revisit when evals or SLAs change.
- 2.2
Design system prompts, templates, and guardrails
Write system prompts and templates with explicit criteria, formats, and boundaries — and place hard must-always rules on deterministic tool-path controls, not prompts alone.
- 2.3
Apply prompt engineering techniques (zero-shot, few-shot, chain-of-thought)
Apply zero-shot, few-shot, and chain-of-thought by failure mode — pick the lightest technique that fixes the problem and earns its tokens under latency SLAs.
- 2.4
Optimize context windows and manage token usage
Budget tokens by layer, keep transactional facts durable, watch position effects, and trim tool results with structured retention — never dump corpora.
- 2.5
Implement prompt reuse strategies (caching, modular prompts, Skills)
Reuse prompts via caching, modular shared instructions, and Skills that isolate verbose workflows — keeping live turns lean instead of inlining everything.
Domain 3 · 19%
Integration
Configure tools and agents, close auth gaps, balance latency, observe systems, and design RAG and connection strategies.
- 3.1
Evaluate tool/agent configuration for capability bloat
Detect oversized toolkits and agent scopes that degrade tool selection, raise blast radius, and hide unused integrations — then shrink, merge, or split by role before adding more prompt text.
- 3.2
Analyze authentication and authorization requirements to identify security gaps
Map AuthN vs AuthZ across UI, agent, and tool principals; find gaps where identity succeeds but permission, least privilege, or verified resource binding is missing.
- 3.3
Evaluate accuracy-latency trade-offs and justify configuration decisions
Justify model, retrieval depth, caching, and tool fan-out against an explicit accuracy floor and latency/cost SLA — quantify deltas and reject one-sided wins that break contracts.
- 3.4
Analyze observability challenges and select monitoring strategies at scale
Instrument LLM-specific SLIs (quality, cost, latency, tool errors), sample traces strategically at high volume, redact secrets, and correlate traces with user outcomes and runbooks.
- 3.5
Design a RAG pipeline with appropriate chunking and indexing strategies
Design structure-aware chunking, provenance metadata, and freshness-safe index promotion so retrieval returns complete, citable units matched to document shape.
- 3.6
Apply retrieval strategies matched to data shape and query pattern
Classify queries (exact ID, paraphrase, filtered browse) and match dense, sparse, hybrid, and structured filters — evaluate per pattern, not only macro averages.
- 3.7
Evaluate connection protocols and select the appropriate integration mechanism (MCP, API/CLI, agent-to-agent)
Choose MCP for shared tools/resources across hosts, API/CLI for owned narrow paths, and agent-to-agent when role isolation and explicit handoffs matter — never secrets-in-prompts.
- 3.8
Evaluate progressive discovery vs. monolithic context strategy
Prefer progressive discovery for large or changing corpora; reserve monolithic (cached) context for small stable packs that fit with headroom — and pin transactional facts outside rolling summaries.
Domain 4 · 16%
Evaluation, Testing & Optimization
Define metrics, build evals, run A/B tests, diagnose failures, and optimize cost and performance.
- 4.1
Define evaluation metrics (accuracy, latency, cost, safety, security)
Define a balanced metric set covering accuracy/quality, latency, cost, safety, and security — tied to user and business outcomes, not a single vanity score.
- 4.2
Design evaluation datasets and test frameworks using mixed methodologies
Build versioned eval datasets and harnesses that mix automated checks, human review, and scenario tests — covering happy path, edge, and adversarial cases.
- 4.3
Conduct A/B testing and iterative improvements
Run controlled A/B tests on prompts, retrieval, and model settings — isolate factors, power the experiment, and ship only when quality and cost clear agreed bars.
- 4.4
Diagnose system issues (prompt failure, hallucinations, model mismatch)
Separate prompt failure, hallucination/grounding failure, retrieval miss, and model mismatch before fixing — reproduce with fixed inputs and traces.
- 4.5
Optimize token usage, latency, and cost-performance trade-offs
Cut tokens and latency without silently dropping required quality — cache and trim before buying capacity; re-measure quality after each cut; batch when interactivity is not required.
- 4.6
Monitor system performance using logging and observability tools
Operate with logs and observability that catch quality and cost regressions — alert beyond HTTP uptime, keep debug context, and close the loop into eval suites.
Domain 5 · 14%
Governance, Safety & Risk Management
Implement guardrails, surface risks, apply HITL, meet compliance, and address ethical AI concerns.
- 5.1
Implement guardrails and safety controls
Layer prompt guidance with deterministic input/output filters, policy checks, and hard blocks on irreversible tool paths — prompts alone never satisfy “must always” safety language.
- 5.2
Identify risks, limitations, and failure modes of LLM systems
Enumerate hallucination, drift, tool misuse, outages, and policy gaps with user impact, mitigations, and residual risk owners — never “the model will handle it.”
- 5.3
Apply human-in-the-loop validation strategies
Route high-risk or ambiguous work to humans with measurable escalation triggers and a structured handoff — facts, suggestion, uncertainty, and required decision.
- 5.4
Ensure compliance with regulations (e.g., GDPR, HIPAA, FedRAMP)
Map data classes, regions, and flows to the named regulatory regime; minimize sensitive data in prompts and logs; document control ownership and evidence.
- 5.5
Address ethical AI considerations (bias, fairness, transparency)
Treat bias, fairness, and transparency as design requirements: measure disparate outcomes, disclose AI involvement when required, and provide recourse — not slogans.
Domain 6 · 14%
Stakeholder Communication & Lifecycle Management
Run discovery, communicate trade-offs, manage feedback and SLAs, document designs, and support the full lifecycle.
- 6.1
Conduct structured discovery and requirement gathering
Run structured discovery that surfaces goals, constraints, data, owners, and measurable success metrics — turn findings into testable requirements before picking a stack.
- 6.2
Communicate architectural decisions and trade-offs
Explain decisions with options, trade-offs, costs, risks, and rationale stakeholders can act on — record them in ADRs so rejected alternatives stay visible.
- 6.3
Manage stakeholder feedback loops and expectation alignment (including SLAs)
Keep feedback loops and SLA expectations aligned through delivery — publish agreed SLAs, review quality and cost on a cadence, and escalate expectation drift early.
- 6.4
Document architectures and provide implementation guidance
Document architecture with diagrams, decision rationale, interface contracts, ownership, and failure runbooks so builders and operators can implement safely.
- 6.5
Support lifecycle phases (discovery, design, handoff, monitoring, iteration)
Support discovery through design, handoff, monitoring, and iteration with explicit exit criteria and ownership — architects who vanish after design miss the lifecycle.
Domain 7 · 7%
Developer Productivity & Operational Enablement
Configure Claude for teams, improve AI-assisted workflows, and support debugging and ops.
- 7.1
Configure Claude tools and environments for teams (e.g., Claude Code)
Standardize Claude Code and related tooling with project-scoped shared rules, skills, and MCP — plus secret hygiene and a documented bootstrap — so personal config never stands in for team standards.
- 7.2
Improve developer workflows using AI-assisted tooling
Embed AI assist into repetitive high-friction steps (review drafts, docs, flaky triage) while humans keep merge/release ownership, and prove value with time saved and error rates — not vanity adoption.
- 7.3
Support debugging and operational issue resolution
Debug Claude, tool, and MCP failures with logs, traces, and minimal fixtures; classify product vs prompt/tool/MCP bugs; capture fixes as reusable runbooks instead of guessing.