Took apart Claude Code, then turned it into a free course on harness

Independent AI engineer Paul Iusztin published an open source curriculum on harness engineering by reverse engineering production systems, as detailed in HN Claude/Codex/Fable's report. After deconstructing Claude Code, OpenCode, and Pi over several months to examine their internal mechanics, Iusztin compiled eight articles, six videos, and a complete Python codebase sponsored by Modal, Opik, and Kitaru to help engineers build custom coding agents from scratch.

This guide analyzes how surrounding runtime scaffolding impacts model output without altering underlying parameters, targeted at developers and systems architects building autonomous tooling across software engineering, finance, and enterprise operations. Readers explore how production-grade harnesses manage process loops, remote sandboxing, context compaction, and subagent delegation across complex operational environments.

What shipped in Took apart Claude Code

The open curriculum delivers a complete reference implementation that models Claude Code within an end-to-end Python repository hosted on GitHub. Structured across eight comprehensive modules, the course guides developers through designing harness architectures and assembling the core execution loop. Practitioners explore local and remote sandboxing barriers, four essential context engineering techniques, and subagent delegation patterns that keep execution state organized. The architecture finishes by deploying headless agents across command line interfaces, webhooks, and cron jobs, accompanied by specialized benchmarking suites and execution replay debuggers.

Authoring the entire system in native Python ensures accessible integration for developers building custom automation without obscure language bindings. Sponsoring support from Modal, Opik, and Kitaru keeps the entire eight-article and six-video series completely free for independent developers. Instead of relying on abstract concepts, the code provides production-grade execution primitives that handle terminal stream parsing, permission boundaries, and structured recovery pipelines. Engineers inspect how real terminal agents isolate operating system interactions and trace system calls during complex automated software development sessions.

What improved in Took apart Claude Code

Harness engineering proves that surrounding models with disciplined runtime scaffolding produces substantial performance improvements without altering underlying model weights. Development teams frequently assume agent failures require fine-tuning or larger foundation models, but empirical data reveals that unoptimized context management, weak tool parsing, and missing feedback loops cause most execution failures. Restructuring harness boundaries resolves these bottlenecks, enabling higher task completion rates while stabilizing inference budgets across demanding interactive terminal workloads. By systematically controlling execution flow, developers achieve production reliability without changing foundation model checkpoints.

Quantitative evaluations on Terminal-Bench prove the concrete performance impact of rigorous harness engineering across identical models. When LangChain upgraded its coding agent runtime while retaining the identical base model, its benchmark accuracy climbed from 53 percent to 67 percent. That 14 percentage point increase propelled the agent from outside the top 30 into the top 5 worldwide on Terminal-Bench. The progression demonstrates that systematic context engineering, disciplined execution monitoring, and robust error propagation deliver measurable benchmark gains that exceed simple prompt adjustments.

What you gain from Took apart Claude Code

Adopting custom harness architecture gives software engineering teams complete control over their agent infrastructure rather than remaining locked into third-party vendor clients. While turnkey command line assistants offer convenient individual utilities, enterprise environments often demand custom compliance boundaries, internal API bridges, and tailored workflows. Companies like Ramp exemplify this approach by building custom harnesses to scale operational workflows instead of relying strictly on tools like Claude Code or Codex. Engineers master four essential context engineering techniques and multi-agent coordination patterns across isolated production environments.

Beyond automated software engineering, the architectural foundations taught in this course power agent deployments in enterprise domains like financial operations, customer sales, and digital commerce. Developers learn to execute agents securely within local and remote sandboxes, isolating untrusted bash executions from production infrastructure and operational databases. Integrating dedicated evaluation benchmarks and execution replay tools allows teams to reproduce failed agent trajectories, pinpoint context degradation, and eliminate regressions before production deployments, transforming stochastic model invocations into predictable and auditable software systems.

How to get Took apart Claude Code

The complete curriculum and Python repository are available on GitHub under decodingai-magazine/building-a-coding-agent-from-scratch-course. Developers working alongside official Anthropic tooling can install or update the command line utility using standard package commands to ensure API compatibility across environments:

npm install -g @anthropic-ai/claude-code

claude update

These official vendor commands maintain direct synchronization with upstream terminal endpoints while developers assemble their own custom Python harnesses. Executing these package managers ensures local developer workstations run validated binaries capable of streaming standard input and managing interactive process lifecycles effectively across target project directories.

Within an active interactive session, developers switch active model engines using in-app slash commands:

/model claude-fable-5-1

/model fable

For automated shell scripts, continuous integration pipelines, or headless batch runs, engineers launch the client with pinned model flags or define standard environment variables:

claude --model fable

export ANTHROPIC_MODEL=fable

These configuration options allow immediate testing between standard vendor tools and custom runtime harnesses, confirming model responsiveness and parameter persistence before deploying autonomous agents into larger production clusters.

What to watch after Took apart Claude Code

As autonomous agents evolve into core enterprise infrastructure, runtime harnesses will increasingly dictate system latency, token costs, and operational reliability. Teams maintaining custom scaffolding must balance rapid local sandbox execution against secure remote isolation to prevent rogue commands from compromising internal systems. Logging detailed execution traces across command line sessions, webhooks, and cron workers will be critical for debugging looping failures and context saturation. Organizations will depend heavily on replay tools to audit model invocations, verify tool outputs, and identify exact trajectory divergence points.

The transition toward custom agent runtimes also accelerates demand for comprehensive evaluation benchmarks that test multi-agent collaboration across realistic enterprise codebases. While Terminal-Bench offers a recognized standard for coding agents, production teams will require domain-specific evaluation suites reflecting private repositories, legacy dependencies, and complex deployment constraints. Tracking whether shared runtime standards emerge or proprietary scaffolding dominates will define the agent ecosystem. Understanding the eight foundational layers established in Iusztin's course equips engineers to navigate these operational developments and construct reliable tools.