Summary: Thinking like an architect

Two teams can build the same assistant with the same model and get opposite outcomes. The difference is rarely the prompt. It is architecture: the set of decisions about what the model decides, what the code decides for it, and what waits for a human. This lesson establishes that judgment layer before the track reads or writes any code.

Core ideas

• Every agentic system is the same four parts: a model (reads, reasons, writes), tools (functions the model can call), a loop (act, observe, decide again), and a context window (the finite desk everything must fit on).
• Everything else is arrangement. The one-sentence spine of the track: architecture is deciding where judgment lives.
• Anthropic’s engineering team draws the field’s most useful line: workflows are systems where models and tools follow predefined code paths; agents direct their own process and tool use as they go.
• A workflow is rigid but repeatable, debuggable, and cheap. An agent is flexible but harder to predict, test, and afford per run.
• The senior move is asking “is the path through this work predictable?” If you can draw the steps and they hold, draw them in code. Reach for a true agent only when the number of steps depends on what the work uncovers.
• The simplest arrangement that fits is the right one. Sophistication is not the goal; fit is.
• Trade-off one, decide versus enforce: an instruction is a request; code is a guarantee. Rules that must hold every single time live in structure the flow cannot skip, not in the prompt.
• Trade-off two, one versus many: specialist teams buy focus, deliberate opposition, and replaceability, but every seam between agents is a place where context leaks and failures hide. Start with one agent; split only when the work itself splits.
• Trade-off three, carry versus fetch: the context window is a budget, and everything on it competes for attention. Decide what the model always carries, what it fetches on demand, and what gets written down outside the window.
• A demo exercises the model. A product exercises the architecture. That is why dazzling demos die quietly and plain ones survive.
• The judgment transfers even as tools churn: these three trade-offs are older than AI. They are how organizations have always been designed.

What changes for you

When someone proposes “let’s add an agent,” you now have the architect’s questions ready: does the path need to be chosen at run time, which rules must be guaranteed rather than requested, and what earns a place on the model’s desk? Ask them before the first line of code, when they cost nothing. The next lesson opens the first concrete surface where these decisions become durable: Claude Code’s team configuration layer.