The 90% number pulled me in. Claude Code — Anthropic’s command-line coding agent — supposedly wrote 90% of its own source code. I opened the architecture expecting task queues, agent hierarchies, and state machines: the usual machinery for deciding what runs when.
Instead I found four lines inside a while loop. A while loop is the plain programming construct that repeats a block until a condition changes. Claude Code’s entire architecture is fundamentally just that one loop — not as a simplification, literally.
The design makes a bet: simplicity scales better than complexity. When the model is good enough, the best thing you can build around it is almost nothing. Give it tools and context, then let it work. Anthropic shipped a CLI that writes 90% of its own code while competitors build orchestration frameworks around the model.
Four lines and a loop
When I first opened up Claude Code’s architecture, I expected layers of abstraction — intermediate code that hides messy details behind simpler interfaces. What I found was closer to a Unix pipeline (small programs passing output to each other) than a microservices mesh (small services talking over a network). The core execution loop looks approximately like this:
while not task_complete:
user_input = get_input()
model_response = call_claude(user_input, context)
results = execute_tools(model_response.tool_calls)
context.append(results)Four lines. One loop.
That leaves out the parts most agent diagrams put in first: a planning layer, a reflection mechanism — where the agent looks back at what it did — multi-agent coordination, and sophisticated memory management.
The answer: trust the model to handle it.
I keep waiting for it to break. It doesn’t.
The other direction
Compare this to what the industry has been building. OpenAI’s Codex-based systems layer complexity on complexity:
- Orchestration frameworks that route tasks between specialized agents
- Planning modules that decompose problems into dependency graphs (maps of which step depends on which)
- Verification layers that check code before execution
- State machines that manage agent lifecycles
- Message queues — async waiting lines that coordinate operations running out of order
That infrastructure rests on one assumption: the model is not smart enough, so the system has to compensate.
Claude Code takes the opposite bet. Claude Sonnet 4.5 is smart enough. Give it tools and context, then get out of the way.
Bash is the adapter
The most elegant decision in Claude Code isn’t what it includes — it’s what it leaves out. Instead of implementing 100 specialized tools (read_file, write_file, list_directory, search_code, run_tests, git_commit, and so on), Claude Code provides one flexible tool: Bash. A tool, in this world, is a defined action the model can ask your code to run.
// Not this:
const tools = [
readFileTool,
writeFileTool,
searchFileTool,
gitTool,
npmTool,
dockerTool,
// ... 94 more tools
];
// This:
const tools = [bashTool];Why does this work? Because Bash is already a universal adapter. Bash is the default shell on Unix systems — the program that runs text commands like ls and grep. Every operation you need — file manipulation, process management, network requests, version control — already has a battle-tested command-line tool behind it. Claude learns to compose those tools instead of learning bespoke, purpose-built APIs.
That choice has five practical effects. Bash tools evolve independently, so Claude Code inherits improvements without maintenance in the framework. Any CLI tool becomes available without a framework change. Developers already know the mental model, so agent behavior is predictable. Standard Unix tools work everywhere. And commands compose naturally (grep | sed | awk — search, transform, and extract end to end) instead of requiring three separate APIs.
When you give Claude Code a task like “find all TypeScript files importing React and count their lines,” it doesn’t need a specialized code-analysis tool. It just runs:
find . -name "*.ts" -exec grep -l "import.*React" {} \; | xargs wc -lIt is the Unix philosophy applied to an agent: do one thing well — Bash execution — and compose when the task is more complicated.
Keep the context small
Here’s where Claude Code diverges most sharply from competitors: context strategy. Context is the running transcript of the conversation the model can see — its working memory for the task.
Most AI agent frameworks obsess over preserving every detail. They build elaborate memory systems — short-term, long-term, episodic, semantic. They implement retrieval mechanisms that surface relevant past interactions. They maintain persistent knowledge graphs (structured maps of facts and their relationships).
Claude Code’s working rule is blunt: the longer the context, the stupider the agent.
That sounds counterintuitive. Don’t agents get smarter with more information? Yes, to a point. Then they get confused. They overthink. They chase irrelevant patterns. They hallucinate connections that don’t exist.
Claude Code aggressively prunes context. Each interaction gets a clean slate with minimal carry-forward. Only essential state survives between turns:
- Current working directory
- Recent file contents (only what’s been read)
- Last few commands and their outputs
- Explicit user instructions
That is it. No elaborate memory system or sophisticated retrieval. Enough context to maintain continuity, then reset.
The result: Claude Code stays focused. It doesn’t get lost in its own history. It doesn’t over-optimize for an edge case from three days ago. It solves the current problem with fresh eyes.
Let the model handle the work
This philosophy shows up everywhere in Claude Code’s design decisions.
It does not need a planning layer
Competitors implement explicit planning phases. The agent must first decompose the task, build a dependency graph, identify risks, then execute.
Claude Code: just start. The model is smart enough to plan implicitly while working. If it needs to think through architecture, it will. If the task is obvious, it won’t waste time.
It does not need a verification layer
Many frameworks require code to pass through verification before execution. Static analysis (automated checks that read code without running it), security audits, confirmation prompts.
Claude Code: execute and observe. If something breaks, the model sees the error and fixes it. This turns out to be faster than trying to verify everything upfront. The model learns from failures more effectively than from pre-execution checks.
It does not need multiple agents
Current AI agent research focuses heavily on multi-agent systems. Specialized agents for different domains, communicating through protocols, voting on decisions.
Claude Code: one agent, one model. Specialization happens through tool selection and context framing, not agent proliferation. One coherent intelligence working the problem beats a committee of narrow specialists.
The loop is the state machine
Frameworks like LangChain — a popular library for wiring agent steps together — implement elaborate state machines to manage agent lifecycles: initialize → plan → execute → reflect → update.
Claude Code: the while loop is the state machine. The model decides when to gather information, when to act, when to verify, when to complete. State transitions happen naturally in the conversation flow, not through enforced checkpoints.
What the 90% means
Claude Code wrote 90% of its own implementation. This isn’t marketing spin — it follows from the architecture rather than from a separate trick.
When the system is simple enough for the AI to understand, the AI can extend it. A human asks for a feature, Claude reads the codebase and implements it, and the human reviews and merges it.
This works because Claude Code’s architecture has minimal abstraction layers. There’s no framework-specific DSL — no custom mini-language you have to learn to drive the framework. No elaborate object hierarchies to navigate — no deep nested taxonomies of code objects. Just straightforward TypeScript (a typed flavor of JavaScript) implementing a simple control loop, the repeating cycle that drives the agent step by step.
As Claude models improve, Claude Code improves too — not through manual development, but through self-modification. The tool evolves with the model powering it.
The contrast with OpenAI Codex
Contrast that with OpenAI’s approach. Codex-based systems (like GitHub Copilot’s agent features) need five specialized subsystems just to run one task. Claude Code needs one while loop. The Codex approach assumes the model needs extensive scaffolding. The Claude approach assumes the model is the scaffolding.
the mechanism — how the loop actually works give me the detail
The Anthropic Messages API returns a stop_reason of "tool_use" when the model wants to invoke a tool. Your loop re-calls the API with the tool result appended as a tool role message — that’s the entire protocol. No framework required.
Here’s a runnable TypeScript skeleton using @anthropic-ai/sdk that implements this exactly — one Bash tool, one loop, nothing else:
import Anthropic from "@anthropic-ai/sdk";
import { execSync } from "child_process";
const client = new Anthropic(); // reads ANTHROPIC_API_KEY from env
const bashTool: Anthropic.Tool = {
name: "bash",
description: "Run a shell command and return stdout+stderr.",
input_schema: {
type: "object",
properties: { command: { type: "string" } },
required: ["command"],
},
};
async function run(task: string) {
const messages: Anthropic.MessageParam[] = [
{ role: "user", content: task },
];
while (true) {
const response = await client.messages.create({
model: "claude-sonnet-4-5",
max_tokens: 4096,
tools: [bashTool],
messages,
});
// Append the assistant turn verbatim
messages.push({ role: "assistant", content: response.content });
if (response.stop_reason !== "tool_use") break; // done
// Execute every tool call the model requested
const toolResults: Anthropic.ToolResultBlockParam[] = response.content
.filter((b): b is Anthropic.ToolUseBlock => b.type === "tool_use")
.map((b) => {
const cmd = (b.input as { command: string }).command;
let output: string;
try {
output = execSync(cmd, { encoding: "utf8", timeout: 30_000 });
} catch (e: any) {
output = e.stderr ?? e.message;
}
return { type: "tool_result", tool_use_id: b.id, content: output };
});
messages.push({ role: "user", content: toolResults });
}
// Final text response
return response.content
.filter((b): b is Anthropic.TextBlock => b.type === "text")
.map((b) => b.text)
.join("\n");
}
run("Count how many TypeScript files are in the current directory.").then(console.log);Try it: npx ts-node agent.ts in any project directory. The model will call bash with something like find . -name "*.ts" | wc -l, your code runs it, feeds back the number, and the model returns a plain-English answer — no framework, no planner, no state machine.
Why context pruning is the real lever: the messages array above is your entire working memory. In production you’d trim it — drop old tool_result blocks once they’re no longer load-bearing, summarize long file reads into a single replacement message. That one discipline (treating context as a budget, not a log) is what prevents the model from drowning in its own history on longer tasks.
When Simplicity Fails
To be fair, this philosophy has real limitations. I’m not fully convinced the trade-offs are always worth it — here’s where I’d hesitate.
Long-Running Tasks
For tasks spanning hours or days, Claude Code’s stateless approach struggles. There’s no checkpoint system — no saved snapshot to resume from — and no resume mechanism. If execution fails midway through a 100-step migration, you start over.
Complex frameworks win here with their state persistence and recovery.
Multi-Domain Expertise
When a task needs specialized knowledge from multiple domains (legal + technical + financial), a single generalist agent may underperform a team of specialized agents.
The multi-agent frameworks have an edge for genuinely cross-functional work. I’d still reach for one there.
Audit Requirements
In regulated industries, you need detailed logs of decision-making. Why did the agent choose option A over B? What information informed that choice?
Claude Code’s implicit reasoning is harder to audit than frameworks with explicit planning phases that log the rationale for each decision.
Resource Optimization
When you run hundreds of agents in parallel, sophisticated orchestration frameworks can optimize resource allocation, queue management, and load balancing (spreading work evenly across machines).
Claude Code’s simple loop doesn’t optimize for multi-tenancy — serving many independent users on shared infrastructure — or resource efficiency at scale.
Why It Works Anyway
Despite those limitations, Claude Code’s architecture succeeds because it optimizes for the common case:
- Most tasks are short-lived (minutes to hours, not days)
- Most tasks are single-domain (write code, debug an issue, refactor a module)
- Most developers prefer transparency over auditability
- Most use cases are single-user (a developer with their CLI)
For this 80% use case, the simple architecture outperforms the complex alternatives. It’s faster to build, easier to understand, simpler to debug, and more reliable in production.
And when you do need the complex features, you can layer them on top. A simple foundation supports extension better than a complex foundation supports simplification.
What to Carry Into Your Own System
Start with the minimal viable control loop, then add complexity only when you hit an actual limitation. A simple loop with implicit state transitions is easier for developers and models to reason about than a complex state machine. Let the model handle planning, verification, and coordination implicitly instead of building a separate system for each.
With frontier models such as GPT-4, Claude 3.5+, and Gemini Ultra, the models are smarter than their orchestration frameworks. Trust model intelligence over framework intelligence: give the model good tools and get out of the way. Let failures happen quickly, observe them, and recover; the model learns more from errors than from elaborate prevention.
Keep the path between model and task short. Every abstraction layer adds latency, complexity, and failure modes. Don’t build bespoke AI agent tools. Before implementing a specialized tool, check whether Bash can do the job, then prefer existing CLI tools that are already reliable, documented, and familiar.
Treat context as a budget. More context usually means worse performance, so prune aggressively and keep only what is immediately relevant.
Measure simplicity by tracking the lines of code in the agent framework. If the framework grows faster than its capabilities, something is wrong. It should remain simple enough that the AI can extend and modify it; that is a forcing function for clarity.
Jon Roosevelt is an AI architect and healthcare technology executive. He builds production AI systems at scale and thinks deeply about what makes software maintainable, reliable, and actually useful. This analysis is based on examining Claude Code’s behavior, architecture patterns, and public documentation — not insider information.