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”.

If you’ve used Claude Code, you may have noticed the /skills command listing installed “skills”. Writing standards, architecture design methods, TDD workflows, code review strategies — it sounds like a plugin marketplace.

Skills are not plugins.

That’s the first and most important thing to understand about the Skill system. A plugin is code — it extends what the program can do. A Skill is a prompt — it extends what the model knows.

Last time we covered context compaction — solving “how much the current session can remember”. But a coding assistant needs another kind of memory: long-term memory across sessions.

You close Claude Code and reopen it tomorrow. What should it know?

• You prefer TypeScript over JavaScript
• You said last time “don’t use the underscore library”
• This project uses Vitest, not Jest
• You once corrected one of its misunderstandings

Context compaction can’t handle these. The session ends, the history clears, tomorrow is a fresh window. If the AI needs you to re-explain everything each time, it isn’t an assistant — it’s a burden.

The Think-Act-Observe loop has a natural enemy: the context window is finite.

Every loop iteration burns tokens — the model’s thinking, the tool-call requests, the tool results. Reading one large file can cost thousands of tokens; a single test run’s output can cost tens of thousands. A dozen rounds in, the context window is stuffed full.

What happens when the window fills? The model says “sorry, this conversation exceeds my context limit”. For casual chat, who cares — open a new window. For a coding assistant, it means amnesia — it forgets the project structure, the changes already made, the user’s preferences.

Giving an AI coding assistant file-write permission is like handing scissors to someone extremely smart who occasionally hallucinates.

Most of the time it knows what it’s doing, but every so often it will confidently delete a file it shouldn’t, or set a critical config to a value that looks plausible and is actually wrong. The model isn’t malicious; it just makes mistakes — usually with great confidence.

If you think a system prompt is just “giving the AI a persona”, Claude Code’s system prompt will upend that notion.

It isn’t a few sentences. It’s a thousand-line template engine made of multiple layers, each responsible for something different: identity definition, behavioral constraints, tool documentation, project context, memory injection, skill loading. Some layers are static (identical every time); others are dynamic (injected in real time based on the project, the session, user preferences).