Claude Certified Architect – Foundations (CCA-F)
Course Curriculum
14 modules designed to master the subject.
Module 1: Exam Orientation and Strategy
Understand the exam structure, scoring model, and how the exam tests architectural thinking over memorization.
Lesson 1: Exam Structure and Scoring Model
Master the mechanics of the CCA-F exam. Understand the weighting of domains, the scoring logic for scenario-based questions, and the structural anatomy of high-stakes AI certification.
Lesson 2: Scenario-based Reasoning Approach
Learn the 5-step framework for solving complex architectural puzzles. Master the deconstruction of goals, constraints, and trade-offs to arrive at the optimal AI system design.
Lesson 3: Domain Weightings and Prioritization Strategy
Strategize your study path. Deconstruct the five domains of the CCA-F, identify high-yield topics, and learn how to allocate your limited preparation time for maximum impact.
Lesson 4: Understanding Distractors and Trap Answers
Master the psychology of high-stakes AI certification. Learn to identify 'too good to be true' distractors and avoid common traps that lure students into technically sound but architecturally incorrect choices.
Lesson 5: Building a Study System
Organize your knowledge for long-term retention. Learn how to build a Pattern-Anti-Pattern library, create high-impact study notes, and prepare a mental dashboard for exam day success.
Module 2: Foundations of Agentic AI Systems
Deep dive into the agent loop (perceive, plan, act, reflect) and the distinction between deterministic and autonomous systems.
Lesson 1: What is an Agentic System?
Define the core nature of agency in AI. Learn to distinguish between simple chat interfaces and autonomous agents that possess delegated executive function and goal-orientation.
Lesson 2: The Agent Loop
Deconstruct the internal physics of autonomous AI. Master the lifecycle of the Agent Loop: Perceive, Plan, Act, and Reflect, and learn how to optimize each phase for reliability.
Lesson 3: Stateless vs Stateful Agents
Master the architecture of AI memory. Learn to distinguish between stateless request-response agents and stateful graph-based agents that maintain persistent context across complex workflows.
Lesson 4: Deterministic vs Autonomous Systems
Master the spectrum of control. Learn how to balance deterministic code with probabilistic AI autonomy to create systems that are as flexible as Claude but as reliable as traditional software.
Lesson 5: When Not to Use Agents
Identify over-engineering traps. Learn the critical criteria for deciding when an agent is the wrong tool for the job, and how to avoid 'AI Hype' in enterprise system architecture.
Module 3: Agentic Architecture and Orchestration
Design multi-agent workflows using Planner-Executor and Supervisor-Worker patterns.
Lesson 1: Single-agent vs Multi-agent Systems
Master the fundamental choice of orchestration. Learn when to use a monolithic 'God Agent' and when to distribute cognitive load across a team of specialized 'Expert Agents'.
Lesson 2: Planner-Executor Pattern
Master the decomposition of complex goals. Learn how to separate high-level strategy from low-level execution to build agents that can solve non-linear problems with high reliability.
Lesson 3: Supervisor-Worker Pattern
Master multi-agent routing. Learn how to design systems where a 'Supervisor' agent oversees a team of specialized 'Worker' agents, delegating tasks and verifying outputs for maximum quality.
Lesson 4: Task Decomposition and Delegation
Master the art of breaking 'Atomic' tasks into 'Sub-Atomic' units. Learn how to prevent hallucination by reducing the cognitive distance between a goal and its execution.
Lesson 5: Coordination Strategies Across Agents
Master the communication protocols of multi-agent systems. Learn the difference between centralized orchestration, peer-to-peer collaboration, and blackboard architectures for distributed AI.
Lesson 6: Tradeoffs in Orchestration
Master the fine-tuning of AI systems. Learn how to navigate the fundamental trade-offs between autonomy and control, and between speed (latency) and robustness (reliability).
Module 4: Tool Design and Integration
Principles of safe, idempotent, and reliable tool interface design using JSON schemas.
Lesson 1: What is a Tool in Agent Systems?
Define the physical interface of AI agency. Learn how Claude interacts with the external world through tool definitions and why 'Semantic Tool Design' is the key to reliable action.
Lesson 2: Exposing Tools vs Embedding Logic
Master the architecture of capability. Learn the decision criteria for when to let the agent call a tool autonomously versus when the system should pre-process data for the agent.
Lesson 3: Tool Interface Design Principles
Design tools that Claude loves to use. Learn the principles of descriptive naming, parameter simplicity, and error-feedback loops that ensure your agent never gets confused by its own capabilities.
Lesson 4: Input and Output Schema Clarity
Master the JSON Schema contract. Learn how to use strictly defined types, enums, and required fields to force Claude into producing perfectly formatted tool arguments every time.
Lesson 5: Idempotency and Side-Effect Control
Master the safety of AI actions. Learn how to design tools that are safe to retry and how to manage side-effects in systems where agents might accidentally double-click a button.
Module 5: Model Context Protocol (MCP)
Standardizing AI-to-Data communication using the Model Context Protocol as a system-level contract.
Lesson 1: What is MCP and Why It Matters?
Define the industry standard for AI connectivity. Learn how the Model Context Protocol (MCP) replaces fragmented API integrations with a unified, standard interface for tools and data.
Lesson 2: Standardizing Tool Communication
Master the messages of the protocol. Learn the lifecycle of an MCP request, from capability discovery to tool invocation, and how standardizing these messages ensures system reliability.
Lesson 3: MCP in Distributed Systems
Scale your AI architecture. Learn how MCP enables context sharing across different servers and continents, and how to manage the security and latency of a distributed agentic network.
Lesson 4: Context Injection via MCP
Master the 'Freshness' of AI memory. Learn how MCP enables real-time context injection, allowing Claude to reference live files, database rows, and system states without bloating the permanent prompt.
Lesson 5: Tool Discovery and Invocation in MCP
Master the lifecycle of action. Learn how MCP clients automate the exposure and invocation of tools, and how to design servers that Claude can navigate without manual instruction.
Module 6: Claude Code Configuration and Workflows
Optimize repository-level AI workflows using CLAUDE.md and scoped configuration hierarchies.
Lesson 1: Claude Code Architecture Overview
Master the internals of the world's most advanced AI coding agent. Learn how Claude Code balances local terminal access with cloud-based intelligence to solve complex repository-level engineering tasks.
Lesson 2: Claude Code Configuration Hierarchy
Master the governance of your AI agent. Learn how to manage global settings, repository-specific rules, and scoped behaviors to ensure Claude Code adheres to your company's unique engineering standards.
Lesson 3: CLAUDE.md Usage and Best Practices
Master project-level AI memory. Learn how to use CLAUDE.md as a high-priority context anchor to provide Claude with architectural 'Ground Truth' and long-term project knowledge.
Lesson 4: Workflow Scoping and Boundaries
Control the blast radius of your AI agent. Learn how to use .claudeignore, command-line flags, and permission structures to ensure Claude Code stays within its intended task boundaries.
Module 7: Prompt Engineering for Architecture
Build predictable, role-based prompts with self-verification and chain-of-thought guardrails.
Lesson 1: Role-based Prompting
Master the psychology of AI personas. Learn why assigning a specific 'Role'—from Senior Architect to Quality Auditor—changes the underlying probability of Claude's output and improves technical accuracy.
Lesson 2: Instruction Clarity and Specificity
Master the directive layer. Learn how to replace ambiguous language with 'Assertion-based Instructions' that leave zero room for model interpretation or hallucination.
Lesson 3: Prompt Decomposition
Master the strategy of 'Multi-step Prompting'. Learn how to break a single complex prompt into a chain of simpler, linked instructions to increase reasoning accuracy and reduce model fatigue.
Lesson 4: Prompt Guardrails and Constraints
Master the defensive layer of prompting. Learn how to implement 'Hard Constraints' and 'Negative Rules' that prevent Claude from going off-topic, hallucinating facts, or violating safety boundaries.
Lesson 5: Prompt Reuse and Versioning
Treat your prompts like production code. Learn how to manage the lifecycle of your instructions, including templating, testing, and Git-based versioning to ensure consistency as models evolve.
Module 8: Structured Output and Schema Design
Convert ambiguous requests into strict, testable JSON outputs for production scale.
Lesson 1: Why Structured Output Matters
Master the deterministic output layer. Learn why enterprise systems require 'Conversations' to be converted into 'Data', and how structured output enables automated testing and downstream processing.
Lesson 2: JSON Schema Fundamentals
Master the language of the contract. Learn the core syntax of JSON Schema, including types, nesting, and metadata, to build robust definitions that Claude can follow with 100% precision.
Lesson 3: Required vs Optional Fields
Master the enforcement of data acquisition. Learn how to use the 'required' array in JSON Schema to force Claude to seek out specific information before completing a task.
Lesson 4: Enums and Constraints
Master the boundaries of data. Learn how to use 'enum', 'min/max', and 'pattern' constraints in JSON Schema to ensure Claude produces mathematically Precise outputs that never deviate from your business logic.
Lesson 5: JSON Validation Strategies
Master the final verification layer. Learn how to implement code-based validation loops to catch, correct, and re-process any JSON outputs that deviate from your schema.
Module 9: Context Management
Control signal-to-noise ratios using pruning, compression, and precision context injection.
Lesson 1: What Context Means in LLM Systems
Define the boundaries of AI memory. Learn how Claude uses the 'Context Window' to reason across files and history, and why managing this space is the single most important lever for both cost and accuracy.
Lesson 2: Context Window Limitations
Master the boundaries of AI reasoning. Learn how to monitor token consumption, handle 'Context Overflow', and optimize your architecture to respect the physical limits of the Claude 3.5 model family.
Lesson 3: Signal vs Noise in Prompts
Master the efficiency of language. Learn how to audit your prompts for 'Token Waste' and how to maximize the information density of every token sent to the model.
Lesson 4: Context Pruning and Compression
Master the automation of memory. Learn how to implement 'Summarization-as-you-go' and 'Rolling Windows' to keep your agents lean, focused, and token-efficient during long-running sessions.
Lesson 5: Multi-turn Conversation Handling
Master the narrative of AI problem-solving. Learn how to manage 'State' across many turns and how to keep Claude from 'Looping' or 'Stalling' when a task requires more than 5 interactions.
Module 10: Reliability Engineering for AI Systems
Design fault-tolerant systems using semantic validation and deterministic fallbacks.
Lesson 1: Identifying Common Failure Modes
Master the pathology of AI systems. Learn to diagnose the four most common ways AI agents fail—from tool hallucinations to logical loops—and how to build architectural defenses for each.
Lesson 2: Retry Logic and Backoff Strategies
Master the resilience of AI systems. Learn how to implement 'Smart Retries' that give Claude the technical feedback it needs to correct its own errors without entering a loop of failure.
Lesson 3: Content Filtering and Safety Layers
Master the governance of AI conversation. Learn how to implement pre- and post-processing filters to blocks PII leakage, toxic content, and prompt injection attacks.
Lesson 4: Human-in-the-Loop (HITL) Patterns
Master the governance of autonomous action. Learn how to design 'Permission Gates' that delegate low-risk tasks to AI while escalating high-risk decisions back to a human supervisor.
Lesson 5: Monitoring and Observability
Master the visibility of AI. Learn how to implement tracing, logging, and performance metrics to ensure your autonomous agents stay healthy, efficient, and secure in production.
Module 11: End-to-End System Design
Synthesize agents, tools, and context into a cohesive, observable, and cost-effective AI system.
Lesson 1: Benchmarking AI Performance
Master the science of measurement. Learn how to distinguish between general benchmarks and domain-specific tests to accurately measure the performance of your Claude-powered agents.
Lesson 2: Scoring Accuracy, Latency, and Cost
Master the triple-constraint of AI. Learn how to create a weighted performance score that balances the quality of the answer with the time and money spent to produce it.
Lesson 3: Building a Custom Evaluation Suite
Master the 'AI CI/CD'. Learn how to build a repository of 'Test Cases' that automatically verify your system's performance whenever you change a prompt, a tool, or a model version.
Lesson 4: Analyzing and Interpreting Eval Results
Master the narrative of the numbers. Learn how to look past simple percentages to identify systemic patterns of failure in your AI evaluations, and how to ignore statistical noise.
Lesson 5: Iterative Improvement Cycles
Master the rhythm of the AI architect. Learn how to turn evaluation data into architectural action, following a strict 'Run-Analyze-Pivot' cycle to reach production-grade reliability.
Module 12: Scenario-Based Problem Solving
Master the art of architectural justification and tradeoff evaluation for high-stakes exam scenarios.
Lesson 1: Understanding Claude Pricing Models
Master the economics of tokens. Learn the difference between input, output, and cached tokens across the Claude 3.5 family, and how to build a cost model for your enterprise agent.
Lesson 2: Token-Efficient Prompt Design
Master the bankruptcy-proof prompt. Learn how to audit your instructions for 'Semantic Overlap' and how to use YAML and code-blocks to minimize the character count of your context.
Lesson 3: Prompt Caching and Reuse
Master the 90% discount. Learn how to implement Anthropic's Prompt Caching to store massive system prompts, tool definitions, and few-shot examples in memory for a fraction of the cost.
Lesson 4: Balancing Performance and Cost
Master the efficiency frontier. Learn how to design 'Model-Switching' architectures that use cheap models for simple tasks and premium models for complex reasoning to optimize your overall burn rate.
Lesson 5: Monitoring and Managing Spend
Master the fiscal governance of AI. Learn how to set token quotas, implement 'Kill-Switches' for runaway loops, and calculate the ROI of your agentic deployments.
Module 13: Practice Exams and Review
Build confidence with timed mock exams and deep metadata-driven error analysis.
Lesson 1: Timed Practice Strategy
Master the rhythm of the exam. Learn how to simulate the CCA-F environment with a 60-question, 120-minute practice session and how to build the 'Mental Stamina' required for success.
Lesson 2: Managing Time Per Question
Master the anatomy of an AWS-style question. Learn how to skim the noise, identify the constraints, and find the 'Primary Metric' (Cost vs. Performance) to answer complex architectural questions in seconds.
Lesson 3: Recognizing Trick Questions
Master the psychology of the exam creator. Learn to identify 'Over-Engineering' traps, 'Model-Name Hallucinations', and 'Double-Negative' constraints that lead common test-takers astray.
Lesson 4: Reviewing Incorrect Answers
Master the psychology of failure. Learn how to perform a 'Post-Mortem' on your incorrect practice answers to identify gaps in your mental model rather than just memorizing facts.
Module 14: Final Review and Exam Readiness
Consolidate high-frequency patterns and verify readiness across all exam domains.
Lesson 1: Review of Key Architecture Patterns
Consolidate your learning. Revisit the fundamental patterns of agentic orchestrations, tool design, and context management that form the spine of the Claude Certified Architect certification.
Lesson 2: Ethics and Responsible AI Architecture
Master the morality of autonomy. Learn how to design systems that avoid bias, respect data privacy, and maintain human agency, ensuring your architectural decisions benefit society.
Lesson 3: Preparing for the Associate Exam (CCA-A)
Master the next level. Learn about the transition from Foundation (CCA-F) to Associate (CCA-A), including deep-dives into prompt caching, advanced MAS orchestration, and complex MCP deployments.
Lesson 4: Final Words and Resources
Cross the finish line. Get the final checklist for your exam day, explore community resources, and join the elite network of Claude Certified Architects.
Course Overview
Format
Self-paced reading
Duration
Approx 6-8 hours
Found this course useful? Support the creator to help keep it free for everyone.
Support the Creator