The Claude Certified Architect exam teaches agent design through production scenarios, and anti-patterns often reveal the right implementation more clearly than recipes do.
2
An agent must branch on the model's stop reason, execute tools in application code, and handle partial responses caused by token exhaustion.
3
Specialized agents, isolated subtasks, controlled context, compaction, and batch mode reduce confusion and operating cost.
Summary
Frank Coyle uses Anthropic's Claude Certified Architect exam as a practical guide to building agentic systems. He begins with the exam's production scenarios and argues that anti-patterns are useful because they show what to avoid. In a customer support loop, the model cannot execute a tool itself. The application must inspect the stop reason, run the requested tool, return its result, and handle cases where the model stopped after running out of tokens. Coyle then covers hierarchical Claude MD files, specialized agents with limited tools, and context boundaries between agents. A critic should receive the claim and evidence without the reasoning that produced them, since shared reasoning can produce groupthink. For developer workflows, subtasks should run in separate context forks and return summaries. Token counts can trigger compaction. He also recommends non-interactive CI workflows and batch mode when work can wait, since Anthropic promises results within at least 24 hours at half the token cost.
Anti-patterns can point engineers toward sound agent designs
Coyle frames the exam through the design-pattern tradition of the early 1990s. Agent systems have recurring patterns, but they also have anti-patterns that show what should not be done. He says this is useful because a bad approach often makes the better approach easier to identify. The exam uses realistic production scenarios rather than isolated technical trivia. It is timed and proctored, and individuals can pay $99 to take it once every six months. Six scenarios are available, with four selected at random for each exam.
The application must inspect stop reasons and run tools itself
In the customer support scenario, Coyle warns against calling the model, accepting its response, and using it without checking what happened. The loop should inspect the stop reason. When the reason is tool use, the model has returned the parameters for a tool, and the application runs that tool before sending the result back. The model cannot execute tools itself. A different stop reason can indicate that the model ran out of tokens, which means the response may be partial and requires further action. After the loop, a confidence check can keep the answer or escalate it to a human.
Claude MD files can impose rules at several project levels
For code generation with Claude Code, Coyle describes Claude MD files as places to put the rules and information the system should follow. Anthropic recommends a hierarchy: one file at the top level of the project, another inside the project folder, and additional files within directories. This gives the system rules that apply at different scopes. Coyle presents the structure as a way to control how Claude Code responds across a project instead of placing every instruction in one undifferentiated location.
Agents should be specialized and receive only the context they need
Coyle calls it an anti-pattern to load one agent with every available tool. He compares that agent to a carpenter who arrives with plumbing, electrical, and carpentry equipment. A better design gives an agent one job and perhaps one or two tools. He also warns against allowing an agent's entire context to spill into the main context. More tokens cost more money and can make the model's answer less accurate. In a critic example, the critic receives the claim and evidence, but not the reasoning that produced them. Coyle says agents that share their reasoning can drift toward groupthink.
Subtasks should run in isolated contexts and return summaries
For developer productivity, Coyle rejects the pattern where every subtask dumps its complete output into the primary thread. He recommends forking the context for a task such as scanning logs for errors. The work and its accumulated tokens stay in the separate context, while a summary returns to the main thread. Long sessions should also be compacted. Coyle describes checking the token count and triggering compaction after a configured limit, giving 150,000 tokens as an example. Anthropic and Claude provide compaction algorithms, and he mentions that custom compression logic can also be written.
Continuous integration should avoid interactive pauses
Coyle warns against putting interactive modes into a CI pipeline. In interactive mode, Claude can stop to ask for permission or confirmation, which interrupts unattended work. He says there are ways to configure the system to run straight through instead. The point is to match the execution mode to the environment: a pipeline needs work that can proceed without someone answering prompts in real time.
Coyle closes with a practical cost-saving suggestion. Prompts and other work can be submitted in a batch when an immediate answer is unnecessary. He says batch mode provides 50% fewer token cost and promises the result within at least 24 hours. That makes it suitable for work submitted before a day off, a vacation, or sleep. The tradeoff is waiting for the result, so it applies when the workflow does not need an interactive response.
"What I want to emphasize here is that what this shows us are something that in the design patterns movement, which came around in the early 1990s with object-oriented programming, we had patterns for objects. We now have patterns for agents, but there's also anti-patterns."02:15
Who should watch
You are preparing for the Claude Certified Architect exam and want to understand the production scenarios behind its questions.
You are building tool-using agents and need practical guidance on stop reasons, tool execution, context boundaries, or compaction.
Your team runs Claude Code in research, developer, or CI workflows and wants to reduce context growth and batch-processing costs.
