Learn Harness Engineering is a course you read, not a package you install

private is set to true, so there is no package to add to your lockfile

The repository is a VitePress site, not a library. Its manifest sets `private` to true and the name to `learn-harness-engineering`, which means the package was never sent to a registry and there is no published artifact for that name to resolve to. If your plan started with depending on this project, there is no dependency line to write.

What you can take instead is the content. The top-level entries divide into `docs/` for the lecture bodies, `docs-readme/` for per-language landing pages, `projects/`, `skills/`, `scripts/`, `tools/` and `assets/`. There is a `CLAUDE.md` at the root, which is worth noticing on a course that teaches you to write an `AGENTS.md` for your own repository: the project keeps a file in that family for itself.

The homepage is a GitHub Pages URL rather than a package homepage. Reading it costs nothing, and installing it is not a thing that exists. That is the correct shape for a course and the wrong shape if you were expecting a harness runtime.

VitePress and mermaid build the course, pdf-lib exports it

The manifest describes itself as course docs powered by VitePress, and the scripts show exactly how. Three pairs are duplicated, which matters before you edit any of them: `dev` and `docs:dev` are the same line, as are `build` and `docs:build`, and likewise `preview` and `docs:preview`. A fourth script, `lecture:run`, is the bare word `tsx` with no file argument, so it does nothing until you supply a path after the script name.

{
  "scripts": {
    "dev": "vitepress dev docs",
    "build": "vitepress build docs",
    "preview": "vitepress preview docs",
    "lecture:run": "tsx",
    "anchors:check": "node --import tsx scripts/validate-anchors.ts"
  }
}

Diagrams come from `mermaid` paired with `vitepress-plugin-mermaid`. To read the course locally, serve the docs directory with the dev script:

npm run docs:dev

Exporting to PDF runs the docs build first and only then the exporter, and the manifest spells out that ordering itself. A separate `pdf:build` script wraps both in one step.

npm run docs:build && npm run pdf:export

That sequence matters if you want a printable copy: the exporter is run after the docs build, and there is no released PDF to download in its place.

Lecture 13 splits every loop into a generator and an evaluator

Lecture 13, titled Why You Need to Stop Prompting Your Agent, moves from a `/goal` command to six primitives: automations, worktrees, skills, connectors, sub-agents and external state. The structural move is a split between a generator and an evaluator, and Project 07 turns that into three experiments in order: a goal loop, a timer loop, and a maker-checker loop. The comparison the project asks you to run is manual against automated, with intervention reduction as the measure.

The templates arrive as four named files: `goal-template.md`, `loop-state-template.md`, `maker-prompt.md` and `checker-prompt.md`. Two of them carry the split directly. `maker-prompt.md` and `checker-prompt.md` are the generator and the evaluator as separate documents, which is what lets you debug a loop by replacing one of them instead of rewriting a single instruction that both produces and grades. `loop-state-template.md` is the piece that has to outlive a process that died mid-run, and a measure like intervention reduction only means something if that state survives.

For a reader sizing the afternoon this costs, the ordering is the useful part. The timer loop comes before the maker-checker loop, so the course makes you build the boring case first and earn the generator/evaluator structure second.

Lecture 14 names three failures a checkpoint inside the loop cannot fix

Lecture 14, From Single Loops to Graph Engineering, stacks four layers, prompt then context then loop then graph, and places harness work below the loop. A graph has four parts: nodes, edges, shared state and routing. The lecture's claim is that in-loop checkpoints cannot repair three failures once a system reaches scale: Goodhart, blindness upward, and conflict.

They are listed as structural rather than incidental, and the course treats all three as things a check inside the loop is positioned wrongly to reach. A check that runs within the loop can only measure what the loop already measures. The lecture's own summary is that a loop is a graph with one node, and that a task needing specialization, parallelism, shared state, verification and recovery has stopped being a loop.

The walkthrough that follows is framework-agnostic, written for people arriving from any agent framework rather than one. The lecture also spends time on graph against workflow, on what it calls the orchestration tax, and on which open-source graph engineering projects existed before the name and which after, which is a useful correction if you have been reading the term as a recent coinage. Project 08 makes it concrete in three steps: draw the maker-checker loop as an explicit graph, add a parallel fan-out and fan-in node, then add a conditional rollback edge and a human-approval node.

The four frontier harness breakdowns are reverse-engineered, not vendor specifications

The August 2026 update adds four pages under Frontier Harness Design Breakdowns, one each for Pi, Claude Code, Codex and DeepSeek. The framing sentence says they apply the course's five-subsystem framework, instructions, tools, environment, state and feedback, to reverse-engineer how four frontier products build real harnesses.

Reverse-engineer is the load-bearing word there, and it is where a reader should slow down. Each page is inference drawn from observable behaviour and public material, not a vendor specification. Pi is described through a minimal kernel, programmable expansion and context engineering. Claude Code through four-layer memory, five-level compaction, hooks and sub-agent isolation. Codex through the repository as source of truth, AGENTS.md as a directory page, and worktree isolation. DeepSeek through everything is a plugin, capability seams and an event pipeline.

The difference from the primary sources the course cites is worth stating plainly. The OpenAI post on harness engineering and the two Anthropic engineering posts are first-party writing about one system each. These four pages are a third party's inference about four systems, wrapped in a course structure the originals do not have. Read the vendor's own post when you need to know what a vendor intends. Read these pages when you want a shape to test your own harness against, and date the hypothesis yourself.

harness-creator scaffolds four artifacts and nothing verifies them

The quick start points at `skills/harness-creator/`, described as scaffolding a production-grade harness for your own project: AGENTS.md, feature lists, `init.sh` and verification workflows, in minutes. That is the most immediately usable thing in the repository and the one place the course crosses from reading into doing.

It is also where the gap opens. The tooling here is a documentation toolchain. `playwright` sits in devDependencies, and the only script that touches it is `screenshots:readme`, which runs `scripts/capture-readme-screenshots.ts` to photograph the rendered docs for the README header. No script in the manifest runs an agent, measures a loop, or checks that a generated AGENTS.md does what its author intended. `anchors:check` validates heading anchors and nothing more.

So the artifacts you are asked to generate are unverified by the thing teaching you to generate them. That is a defensible choice for a course and a real cost for you: no script in the manifest executes the verification workflows in the scaffold, so proving they work becomes a job for your own CI. The course's five subsystems include feedback, and feedback is the one the course has not instrumented on itself.

Fifteen translated READMEs, but every lecture link points into docs/en

The header offers the course in 15 languages, and each badge points at a separate README under `docs-readme/`: zh-CN, zh-TW, ja-JP, ko-KR, es-ES, fr-FR, ru-RU, de-DE, ar-SA, vi-VN, uz-UZ, tr-TR, pt-BR and uk-UA, alongside the English root README. Two of the What's New tables close with a row claiming full translation coverage across all supported languages.

What the links demonstrate is narrower than that row reads. Every locale badge in the banner targets `docs-readme/<locale>/README.md`, a landing page. Every lecture link in the same file, covering Lecture 13, Lecture 14, Project 07, Project 08 and all four harness breakdowns, targets `docs/en/`. The README itself links fifteen language landing pages and only the English lecture tree.

If you are deciding whether this course is readable in your language, that distinction is the whole answer. A reader working in Turkish or Ukrainian can confirm that a landing page exists for them and cannot confirm that the lecture bodies do. Opening a single `docs-readme/<locale>/` directory before you plan fourteen lectures around the material is the cheaper way to find out, and it costs one click.

No GitHub releases, and version 0.1.0 is a placeholder

The repository has no GitHub releases at all, and the manifest carries version 0.1.0 with `private` set to true. Together those mean the course has no version stream to pin. Nothing tells you which revision you are reading.

The last push was on 2026-10-22. For a body of prose that describes specific behaviour inside commercial products, that date is the only anchor on how current the material is. The four harness breakdowns are the part most exposed to this, because they make claims about internals of tools that ship often. The README's own August 2026 heading dates the section rather than the behaviour it describes, and nothing in the repository pins which versions of Pi, Claude Code, Codex or DeepSeek those pages were written against.

The licence is MIT, which for a documentation repository means you can fork it and translate it without asking anyone. Given fifteen front doors and a `docs-readme/` layout, that is the licence's most useful effect here, and the one piece of this project you can safely treat as stable and versioned: your own fork.

Editorial conclusion

Read this course if you are building an agent harness and want a named framework, four templates and a third party's account of how four commercial harnesses are put together. Skip it if you need a runtime, a library or a version you can pin, because the manifest is private and the repository has no releases. Before you plan time around it, open one docs-readme directory in your own language and check whether the lecture bodies are there, rather than only the landing page.

Frequently asked questions

Official sources

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