The Architect's Workshop — Building Full Apps with Multi-Agent AI

Getting an AI to build a full app over several hours usually ends in a half-finished, buggy mess because the model loses track of what it's doing or hallucinates a solution. This workshop breaks down exactly how Anthropic solves that by changing the architecture around the AI, rather than just waiting for a smarter model.

Here are the core takeaways, bridging the gap from high-level concepts to actionable development patterns:

1. Stop Letting AI Grade Its Own Homework

Large Language Models are natural people-pleasers. If you ask a single agent to write a feature and then ask that same agent to check for bugs, it will almost always rubber-stamp its own mistakes and confidently tell you it looks great.

The Architecture: Split the workload into separate, isolated roles — specifically a "Generator" (builder) and an "Evaluator" (critic). This mimics generative adversarial networks (GANs).

The Execution: Give the Evaluator a ruthless grading rubric. Instead of just reading the raw code diffs, the Evaluator actively runs the app. It uses browser automation tools (like Playwright) to literally open the webpage, click buttons, look for overlapping text, and judge the design. If it fails the test, it hands a granular, actionable critique back to the Generator.

2. Negotiate a "Contract" Before Coding

When humans build software, they don't define every single backend variable on day one. AI shouldn't either, because early mistakes cascade and ruin the whole multi-hour run.

The Architecture: Introduce a third role: a high-level "Planner." Its only job is to break a vague prompt (e.g., "build a retro game") into sprints. It strictly avoids planning the granular technical details.

The Handshake: Before a single line of code is written, the Generator and Evaluator negotiate what "done" actually means. The Generator proposes a feature and the tests for it. The Evaluator pushes back if the scope is too broad or misses edge cases. They iterate until they agree on a specific checklist (a contract). The Evaluator then grades the final work against this contract, not the vague original prompt.

3. Use the File System as a Shared Brain

Relying entirely on the AI's active memory (its context window) to coordinate multiple agents over six hours leads to "context rot" — the AI forgets early instructions or gets anxious as the memory fills up.

The Architecture: Move state management out of the context window and onto the hard drive.

The Execution: Have the agents communicate and track progress by writing to simple, persistent files (like a progress.json or a markdown feature checklist). This acts as an anchor. If the Generator gets hopelessly stuck or the loop needs to restart, the agents can just read the file system to instantly understand the current state of the project without needing the entire chat history.

4. The Unglamorous Secret: Read the Traces

If you are building your own AI loops and they keep failing, the solution isn't necessarily more clever prompting or complex scaffolding.

The Execution: You have to read the raw, unedited execution logs (traces) of what the AI was doing step-by-step.

Why it matters: It builds developer empathy. By reading exactly where the AI misunderstood a layout issue, or why it thought a broken button was acceptable, you can adjust your Evaluator's rubric to catch that specific blind spot next time.