Lesson 13 – Claude Certified Architect – Full Course

The Core Dilemma in AI-Assisted Development

This lesson tackles a fundamental challenge that separates productive AI developers from those who spend more time debugging than building: choosing the right operational mode in Claude Code. The instructor opens with a powerful anecdote about a 40,000 line mistake, immediately framing the stakes. When you instruct an AI agent to build something complex without the proper planning stage, it can generate massive amounts of code that becomes a nightmare to untangle. The distinction between Plan Mode and Direct Execution is not just a technical preference; it is a professional decision framework that determines whether your output is clean, maintainable, and functional.

The session introduces two primary modes in Claude Code. Direct execution is the default, where the agent receives a task and immediately begins writing files and generating code. This is seductive because it feels productive in the moment, but for complex tasks with architectural implications, it is the fast track to context window exhaustion and unmaintainable codebases. Plan mode, by contrast, operates more like an architect's blueprint phase. It decouples the planning from the building, allowing the AI to map out a strategy, understand the file structure, and reason about dependencies before a single line of production code is generated.

The Four-Question Decision Framework

A key takeaway from the lesson is the practical, repeatable framework used to decide between the two modes before typing a single prompt. The instructor presents four guiding questions. First, consider the scale of the change. Is this a single bug fix that touches one function, or a request to build a feature spanning multiple components? Second, evaluate architectural impact. Will the change introduce new patterns, modules, or data flows? Third, assess certainty. Do you know exactly the line and function that needs modification, or is the solution still ambiguous? Fourth, reflect on consequence. If the change is wrong, what breaks? This framework transforms a gut-feel decision into a systematic evaluation, which is exactly the kind of competency the Claude Certified Architect exam tests.

By applying these questions, a developer can preemptively avoid the spiral where an AI agent starts generating plausible-looking but ultimately incorrect structures. The lesson emphasizes that direct execution shines in tractable, small-scale scenarios where the solution space is clear. Plan mode becomes indispensable when the task requires coordination across multiple files, introduces new components, or involves an uncertain solution path that benefits from architectural deliberation before resource-intensive code generation begins.

Practical Application Through the Monolith Migration Scenario

The didactic power of this lesson shines in the exam scenario breakdown concerning a monolith migration. The instructor presents sample question five, which poses a classic enterprise problem: migrating a monolithic application to a microservices architecture. This scenario is a perfect stress test for the decision framework. The naive approach would be to prompt the agent with "migrate this monolith to microservices" and let it run wild. The video carefully deconstructs why the correct answer is Plan Mode, using the four-question framework to justify the decision.

The analysis reveals that a monolith migration has massive scale, introduces profound architectural changes, involves tremendous uncertainty in service boundaries and dependencies, and carries catastrophic consequences if the migration goes wrong. The instructor methodically walks through why a direct execution approach would likely produce a tangled set of partially migrated files that compile but fail at runtime due to broken service communication. This scenario grounds the theoretical framework in a concrete, high-stakes context that mirrors real-world architectural decision-making found in senior engineering roles and certification exams.

Building a Kanban App Live with Plan Mode

The lesson's centerpiece is a live demonstration where the instructor builds a realistic Kanban application from scratch. This segment begins by creating a detailed plan, which Claude Code treats as a spec document. During the planning phase, the AI explores the required file structure, component hierarchy, data flow for task management, and state handling for drag-and-drop columns. The observation of Plan Mode in action reveals that it functions as a discovery mechanism, allowing the architect to review and refine the intended approach before committing to the expensive process of code generation.

After the plan is validated, the instructor switches to Execute Mode, where the agent now works within a well-defined constraint space. The difference is stark. Code appears at a steady pace, with the agent making architectural decisions consistent with the plan. The end result of the demo is a functional, interactive Kanban board, demonstrating that a small upfront investment in planning dramatically increases the probability of first-pass success. The audience also sees how the plan becomes a living document, serving as a reference if mid-stream refinements are necessary.

Managing Context and Preventing Exhaustion

A critical technical segment of the video addresses the Achilles heel of AI coding agents: context window exhaustion. The instructor explains how the Explore subagent functions as a crucial tool for preventing the main agent from running out of processing memory. When dealing with large codebases or multi-stage tasks, an AI can consume its window rapidly by trying to load entire files and histories. The Explore subagent acts as an information scout, loading files, summarizing relevant sections, and returning only the essential context to the main agent.

This architecture allows Plan Mode to operate efficiently even on sizable projects. By dispatching the Explore subagent to investigate files, directory structures, and existing dependencies, the main agent preserves its context budget for the actual planning and reasoning tasks. The lesson makes clear that mastering these subagent patterns is a distinguishing skill for a Certified Architect. The techniques shown provide a template for scaling AI-assisted development beyond toy examples, into real applications with hundreds of files and complex dependency graphs.

Iterative Refinement and Communication Patterns

The final portion of the lesson introduces three iterative refinement patterns: the Interview Pattern, the Pause Pattern, and the Test-Driven Iteration. The Interview Pattern reverses the typical dynamic by having the agent ask clarifying questions before generating code, creating a structured dialogue that prevents misaligned assumptions. This pattern is especially valuable in Plan Mode, where the agent can identify missing requirements and actively seek clarification instead of guessing and generating incorrect code.

The video demonstrates this pattern through a practical exercise where the instructor responds to the agent's clarifying questions, which refine the plan's precision. The accompanying discussion of effort levels and model switching shows how developers can dynamically adapt the intellectual horsepower of the agent based on the task's current phase. For example, quick structural decisions might use a fast, lightweight model, while a complex architectural trade-off might demand the most powerful model with a high effort setting. This adaptive resource allocation treats AI compute as a strategic budget, not a fixed setting.

Preparing for the Certification Exam

The session concludes with an exam master cheat sheet, distilling the entire lesson into actionable memorization points for those pursuing the Claude Certified Architect credential. The cheat sheet reinforces the non-negotiable rule: Plan Mode for any task with architectural impact, multi-file scope, or uncertain requirements; Direct Execution for small, well-understood, single-file changes. The instructor also highlights common exam traps, such as scenarios where a task sounds simple but actually implies multi-layer changes, making it a Plan Mode problem under a superficial disguise.

Beyond exam preparation, the lesson provides a production-grade mental model for clean AI-assisted software development. The ability to switch between planning and executing, to deploy subagents for context management, and to interview the AI to lock in requirements transforms the developer from a code monkey prompting for boilerplate into an architect orchestrating an intelligent digital workforce. The lesson's 52 minutes equip the viewer with the judgment to avoid becoming the protagonist of their own 40,000 line mistake story.