Attachment download: Agent Interview Questions.pdf — handy for printing or offline reading

Why Would You Need Multiple Agents

An opening question to separate people who have “read the articles” from people who have “actually built one”.

The bad answer: “Multi-agent enables parallel processing, which improves system throughput and robustness.”

Every word of that is correct, but if you follow up with “so after splitting into two agents, did throughput actually double?”, they stall. The reality: inter-agent communication has overhead, coordination has complexity, and after the split total throughput may well drop. Adding agents is not like adding CPU cores.

Twelve articles, from the Think-Act-Observe loop all the way down into the 500,000-line engineering abyss. Now, standing at the end of the series and looking back over the whole evolutionary path, a bigger question surfaces:

What will AI coding tools ultimately evolve into?

A better Copilot? A more powerful IDE plugin? Or something new that we haven’t named yet?

Three Evolutionary Paths

Looking back at the development of AI coding tools, you can see three clear stages of evolution:

The claude-code-from-scratch project implements a “mini Claude Code” in roughly 3,000 lines of TypeScript. It has the Think-Act-Observe loop, a tool system, a system prompt, permission control, memory, Skills, multi-agent, MCP — every core concept we tore down over the previous ten posts.

And the official Claude Code source? Roughly 500K lines of TypeScript/TSX.

That’s a 100x+ gap between 3,000 lines and 500K. What’s in it?

The gap isn’t “number of features”. from-scratch already covers every core concept. The gap is the road each concept travels from “it runs” to “it’s usable” — that road is called productionization.

Hand an architect a plot of land and he won’t start laying bricks immediately. He draws first, calculates load, considers daylight, plans the plumbing. Only when the blueprints are confirmed does the construction crew move in.

Hand an AI coding assistant a requirement and by default it starts editing code immediately. Not because it doesn’t understand “design first”, but because its loop mechanism rewards action — in the Think-Act-Observe loop, “Act” is the core capability. The model is trained to be “helpful”, and “helpful” in a coding context usually means “start changing things”.

Before MCP, every AI tool integration was a custom build. Want ChatGPT to reach a database? Write a plugin. Want Claude to call the GitHub API? Write a Function Calling definition. Want Copilot to access your internal systems? Write a Custom Tool.

Every time, the same thing: define an interface, write adapter code, handle auth, manage errors. The wheel, reinvented countless times.

The problem MCP (Model Context Protocol) solves is simple: give AI agents a standard protocol for connecting tools. Just as USB-C gave electronic devices a universal connector, MCP gives AI agents a universal tool interface.

There’s a counterintuitive phenomenon: take the same model, split it into multiple independent instances, and have them collaborate — the result is often better than a single instance.

Not more compute (three instances burn more total tokens than one), not more capability (every instance is the same model). The gain comes from role separation — when each agent attends to only one facet of the problem, it works with more focus and more depth than a “do-everything agent”.