How to code Claude Code in 200 lines of code

TL;DR Highlight

A post showing that the core structure of AI coding agents is just LLM + tool-call loop — provable with 200 lines of code. The magic isn't magic.

Who Should Read

Engineers curious about how coding agents work internally, and devs deciding whether to build their own agent vs. use an existing framework.

Core Mechanics

The core loop of a coding agent is: (1) give LLM a task + available tools, (2) LLM decides which tool to call, (3) execute tool, (4) feed result back to LLM, (5) repeat until done.
This loop can be implemented in ~200 lines of Python with no frameworks — the agent capability comes from the LLM's reasoning, not the scaffolding.
The tools in the demo include: read_file, write_file, run_bash, search_files — four tools are enough for a functional coding agent.
The post demonstrates that frameworks like LangChain, AutoGPT, etc. add value through reliability, error handling, and ecosystem, not through any magical capability the base loop doesn't have.
Understanding the base loop is essential for debugging agent behavior — most failure modes are traceable to specific tool call decisions, not mysterious emergent behavior.
The implementation also illustrates token budget management — long tool outputs need to be truncated/summarized before feeding back to the LLM.

Evidence

The actual code was shared and verified by HN readers — several forked it and confirmed it works as described.
Debate about whether 'agents are just tool-call loops' undersells the complexity — the context management, error recovery, and planning behavior of production agents is non-trivial.
Consensus emerged that the 200-line version is sufficient for simple tasks but production agents require significant additional work on reliability and observability.
Several engineers noted this is the implementation they wish they'd had when first learning about agents — the conceptual clarity is valuable even if you end up using a framework.

How to Apply

Build the 200-line version yourself before using any agent framework — understanding the loop makes debugging infinitely easier.
When evaluating agent frameworks, look for what they add on top of the base loop: structured logging, retry logic, tool validation, state persistence. These are the real value-adds.
For simple internal automation tasks, the 200-line version may be all you need — avoid framework overhead when the task is well-defined.
Use the base loop architecture when you need to understand and control exactly what's happening — production frameworks can obscure the decision-making process.

Code Example

snippet

import anthropic
from pathlib import Path

client = anthropic.Anthropic()

# Define 3 tools (read_file, list_files, edit_file)
# Main loop
while True:
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=8096,
        system="You are a coding agent...",
        tools=tool_specs,  # Tool list converted to JSON Schema
        messages=conversation
    )
    # If tool_use response, execute locally and append result to conversation
    # If text response, print and exit loop

Terminology

Tool-call loopThe fundamental agent pattern: LLM chooses a tool, tool executes, result is fed back to LLM, repeat — continuing until the task is complete or the LLM signals done.

ScaffoldingThe code surrounding an LLM call — tool definitions, response parsing, context management, error handling — as distinct from the model itself.

Token budgetThe maximum number of tokens that can be in a model's context — long tool outputs must be truncated or summarized to stay within this limit.