Anthropic's CCA Exam as a Field-Guide for Agentic Engineering — Frank Coyle, UC Berkeley

Frank Coyle demystifies the Claude Certified Architect exam by dissecting key scenarios and highlighting common anti-patterns in Agentic AI design. He provides actionable best practices, emphasizing effective tool use, context management, specialized agent architectures, and cost-saving techniques, all centered on understanding what to avoid to build robust LLM applications.

August 8, 2026 5 min read

Anthropic's CCA Exam as a Field-Guide for Agentic Engineering — Frank Coyle, UC Berkeley — source: https://www.youtube.com/watch?v=Z-c11pV_uvU

Introduction to Agentic AI and the Claude Certified Architect Exam

Frank Coyle, a computer science educator for over 30 years, introduces the Claude Certified Architect exam as a critical pathway for professionals navigating the evolving landscape of Agentic AI. Emphasizing a philosophy of “experiment, experiment, experiment,” Coyle advocates for hands-on experience and a deep understanding of not just what to do, but crucially, what not to do—referring to this as “anti-patterns.”

The Claude Certified Architect Exam

Released in March, this new exam is timed, proctored, and scenario-based, providing realistic constraints for its multiple-choice questions. It covers five key domains:

Agentic Architecture (27%)
Claude Code Configuration and Workflow (20%)
Prompt Engineering and Structured Output (JSON)
Tool Design and Model Context
Context Management and Reliability

The exam presents six production scenarios, randomly selecting four for each test-taker. Coyle’s insights focus on common anti-patterns within these scenarios, guiding toward effective solutions.

The Power of Loops in Agentic AI

Coyle highlights that while loops have been fundamental to Turing complete programming languages since 1966 (alongside sequential statements and conditionals), their resurgence in Agentic AI is giving rise to exciting new capabilities. The focus on loops enables agents to perform iterative tasks, a core component of sophisticated agentic systems.

Scenario 1: Customer Support Resolution Agent

Anti-pattern: Naive Model Interaction

A common anti-pattern is simply calling the LLM, taking its response, and directly using it without further checks.

Best Practice: Branching on `stop_reason`

LLMs are fundamentally “probabilistic next word predictors” and cannot execute tools themselves. They can only return parameters that your code then uses to execute the tool. Therefore, it’s critical to:

Check stop_reason: The LLM will indicate tool_use when it has identified the need and parameters for a tool. Your code then executes the tool based on these parameters.
Handle token_limit: If the stop_reason indicates a token_limit was reached, the LLM’s response is partial. This requires immediate action, as the answer received is incomplete.
Human-in-the-Loop: Post-LLM response, incorporate human review if confidence is low, or escalate as needed.

Scenario 2: Code Generation with Claude

Claude code utilizes claude.md files to define hierarchical rules. This allows for tailored configurations at the project, folder, and directory levels, controlling how the system responds across different scopes of your codebase.

Scenario 3: Multi-Agent Research System

Anti-pattern: Overloaded Agents & Context Sprawl

Avoid creating a single, monolithic agent loaded with every possible tool (likening it to a carpenter bringing plumbing and electrical gear). Also, letting agent context spill over into the main context is detrimental, increasing token usage (cost) and potentially confusing the LLM.

Best Practice: Specialized Subagents & Context Isolation

Specialization: Design agents to do “one thing,” equipped with only one or two relevant tools. This mirrors functional programming principles and enhances efficiency and clarity.
Context Scoping: Each agent should operate with only “its own slice” of context. For instance, a “critic agent” should be given only the “claim and the evidence,” not the reasoning process that led to them. This prevents “groupthink” among agents, where they might converge on a single idea, much like humans in a social setting.

Scenario 4: Developer Productivity with Code

Anti-pattern: Unbounded Context Growth

Letting every subtask dump its full output into the primary thread leads to an unmanageable and costly context window.

Best Practice: Subtask Isolation and Compaction

Forking Context: When an agent undertakes a subtask (e.g., scanning logs for errors), “fork” its operations into a separate thread. This ensures that the agent’s internal thoughts and token usage do not “pollute” the main context.
Summary to Main Thread: Only a concise summary of the subtask’s output should be returned to the primary context, keeping it lean and relevant.
Token Count Checks & Compaction: Implement checks for the current token count. If a predefined threshold (e.g., 150,000 tokens) is exceeded, trigger compaction algorithms. Anthropic provides such algorithms, and it’s also possible to implement custom logic for context compression.

Claude Code for Continuous Integration

Anti-pattern: Interactive Modes in Pipelines

Interactive modes, which require user prompts for decisions or permissions, are unsuitable for automated CI/CD pipelines.

Best Practice: Non-Interactive Configuration

Configure Claude to run straight through without requiring human intervention, enabling seamless integration into automated workflows.

Cheap Win: Batch Mode Processing

For tasks that are not time-sensitive, leveraging Claude’s batch mode can yield significant cost savings. Running work in batch mode can reduce token costs by 50%, with results typically delivered within 24 hours. This is an efficient option for asynchronous processes.

Conclusion: Embrace the “Make” Philosophy

Coyle concludes by reiterating the core philosophy: “Nothing is a mistake. There’s no win and no fail. There’s only make.” He encourages continuous experimentation and building, affirming that through this iterative process, success in Agentic AI can be achieved.