Learn Harness Engineering: A Project-Based Course on Reliable AI Coding Agents

What Harness Engineering Means in the AI Agent Context

The term harness engineering, as used in this course, refers to the scaffolding around a language model that keeps it on task during long-running multi-turn interactions. The harness includes the instructions the agent receives, the tools it can call, the environment it operates in, the state it carries between turns, and the feedback mechanisms that verify whether it completed its work correctly.

The course is a direct response to two published frameworks: OpenAI's writing on leveraging Codex in an agent-first world, and Anthropic's two posts on effective harnesses for long-running agents and harness design for long-running application development. Those posts introduced the term; this course builds curriculum around the ideas they outline.

The problem the course targets is specific: AI coding agents that lose context mid-task, declare completion before they have actually finished, or produce inconsistent results because their environment is not stable between turns. These are not model quality problems; they are engineering problems in the scaffolding surrounding the model. The course argues that fixing them requires deliberate design at the harness level, not repeated prompt adjustments.

Course Structure: Lectures, Projects, and the Template Library

The course is organized around 14 lectures and 8 projects as of the August 2026 update. Each lecture addresses a specific mechanism or failure mode, and each project is a hands-on exercise that applies the lecture's ideas to a real task.

Alongside the lectures and projects, the repository includes a ready-to-use resource library of templates. The templates added in the July 2026 update include `goal-template.md`, `loop-state-template.md`, `maker-prompt.md`, and `checker-prompt.md`. These are intended to be dropped directly into a project rather than serving as examples to study. The README describes their purpose: solving common pitfalls in multi-turn AI agent development, specifically context loss and premature task completion.

A separate `skills/harness-creator/` directory contains a skill that can scaffold a production-grade harness for a new project. The README states it produces AGENTS.md files, feature lists, init.sh scripts, and verification workflows. The scaffolding tool is intended to compress the setup time from reading the course to applying it.

PDF coursebooks are available as an export. The `pdf:build` script in package.json builds the VitePress documentation site and then runs the PDF export, which produces downloadable versions of the course content.

Running the Course Site Locally and Getting the Templates

The course documentation is built with VitePress and hosted at the walkinglabs.github.io website. To run the site locally after cloning the repository:

git clone https://github.com/walkinglabs/learn-harness-engineering
cd learn-harness-engineering
npm run dev

The `npm run dev` command starts a local VitePress development server. To build a static export:

npm run build

To build and export PDF coursebooks:

npm run pdf:build

The `pdf:build` script runs the VitePress build followed by the PDF export script. The PDF output depends on Playwright being available, since the export script uses it for page capture.

The template files in `skills/harness-creator/` and the drop-in templates added in July 2026 are plain text files in the repository and do not require building the site to use. A developer can clone the repository and copy the templates directly into their own project without running any build step.

The course is available in 15 languages, with full translation coverage added alongside each major content update. The English source lives in `docs/en/`.

The Five-Subsystem Framework at the Course's Core

The curriculum is organized around a five-subsystem framework: instructions, tools, environment, state, and feedback. Each subsystem corresponds to a distinct engineering concern in an AI coding agent harness.

Instructions covers what the agent is told to do and how that information is structured. Tools covers what capabilities the agent can invoke. Environment covers the state of the filesystem, the running processes, and the external services the agent can reach. State covers what the agent knows about the current task and its own progress between turns. Feedback covers how the harness checks whether the agent's output is correct.

The Frontier Harness Design Breakdowns section, added in August 2026, applies this framework to four commercial products: Pi, Claude Code, Codex, and DeepSeek. Each breakdown reverse-engineers how the product builds its harness using the five subsystems as an analysis lens. The Claude Code breakdown covers its four-layer memory system, five-level compaction, hooks, and sub-agent isolation. The Codex breakdown covers its use of AGENTS.md as a directory page and its worktree isolation approach. The DeepSeek breakdown covers its plugin architecture and event pipeline.

These breakdowns are the most concrete section of the course for developers who are already working with specific tools and want to understand how those tools are built internally.

Loop Engineering and Graph Engineering: The Advanced Sections

Lecture 13 covers loop engineering, which the course defines as the design of the automated execution path that the harness runs. The lecture introduces six primitives: automations, worktrees, skills, connectors, sub-agents, and external state. It also covers the generator and evaluator split, four silent costs of agentic loops, and a step-by-step guide to building a first loop.

Project 07 applies loop engineering with three progressive experiments: a goal loop, a timer loop, and a maker-checker loop. The maker-checker pattern uses two agents in sequence, where one produces output and the other checks it, and the loop continues until the checker approves.

Lecture 14 covers graph engineering, which the course frames as the natural extension of a single loop when a task requires parallelism, shared state, verification at multiple levels, and recovery paths. The lecture describes a four-layer stack: prompt, context, loop, and graph. It introduces a six-step walkthrough for building an explicit graph and discusses the orchestration cost of graph-based designs.

Project 08 applies graph engineering through three experiments: drawing an existing maker-checker loop as an explicit graph, adding a parallel fan-out and fan-in node, and then adding a conditional rollback edge and a human approval node. These are designed to be done on top of a project the course participant is already working on, not as toy examples.

Maintenance and What the Repository Does Not Cover

The last push to the repository was on August 26, 2026. The August 2026 update added the Frontier Harness Design Breakdowns section with four product analyses and full translation coverage across all 15 supported languages.

The course is MIT-licensed. The documentation and templates in the repository are free to use, copy, and adapt, including in commercial projects. The license does not restrict use of the templates or scaffolding tools.

The course does not cover model training, fine-tuning, or machine learning theory. It is about the software engineering layer above the model, not about the model itself. It also does not cover evaluation benchmarking or model selection; those topics require different tooling and are outside the stated scope.

The repository has no GitHub releases. Updates are tracked through the README's What's New section, which records the date and content of each update. Users who want to track changes should watch the repository or check the What's New section directly.

Where This Course Fits and Where It Ends

Learn Harness Engineering occupies a specific position: it addresses the engineering layer between a prompt and a working multi-turn AI coding agent. It assumes the reader has an LLM API key, knows how to write code, and has already tried building an agent that did not behave reliably.

The course does not replace documentation for specific tools like Claude Code or Codex; it provides a framework for understanding and extending those tools. The Frontier Harness Design Breakdowns section bridges this gap somewhat by analyzing how real products implement the five-subsystem framework, but those analyses are descriptive rather than tutorial-style walkthroughs.

For developers who want to go deeper on a specific framework, the `skills/harness-creator/` tool is the most direct path from reading the course to producing working configuration files for a project. The README states it can produce a production-grade harness scaffold in minutes, covering AGENTS.md, feature lists, init.sh, and verification workflows. Whether that claim holds for a specific project depends on how standard its structure is, and the README does not document what it generates for non-standard cases.

Editorial conclusion

This course is a good match for developers who are already building AI coding agents and running into context loss, premature completion, or coordination failures at scale. It is not aimed at people learning machine learning fundamentals or model training; those topics are outside its scope entirely. Before starting, check whether the lecture on graph engineering (Lecture 14) or the frontier harness design breakdowns cover the specific system you are building: those two sections are the most concrete and the most likely to change how you approach a specific design problem.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository