Harness Engineering, end to end.

You end with: A written failure inventory for your own repository: the three ways your agent most often goes wrong.

You end with: A one-page sketch of the five harness layers as they exist (or don't) in your project today.

You end with: A PIVE checklist file your agent reads at the start of every task.

You end with: A measured before/after: the same task run prompt-only and rules-first, with the diff between them.

You end with: A repository map the agent can load: what exists, where it lives, what is authoritative.

You end with: Your instruction set split into a root contract plus scoped rule files.

You end with: Three reusable commands and a rule file, checked into the repository.

You end with: A workspace an unfamiliar agent can orient in without you narrating it.

You end with: A next-task file with an explicit scope surface and exclusions.

You end with: A feature list for one real change, sized so the agent finishes it.

You end with: A continuity file that survives a context reset with no information loss.

You end with: An initialization routine the agent runs before touching any code.

You end with: A context budget for your repository and a tool belt with everything unearned removed.

You end with: One task carried across three deliberate session restarts without losing state.

You end with: A definition-of-done the agent must satisfy with command output, not prose.

You end with: One end-to-end gate wired into your task loop.

You end with: A run log the agent writes as it works, readable after the fact.

You end with: A feedback signal that corrects the agent mid-run instead of after it.

You end with: A verification pass the agent runs on its own work before reporting.

You end with: A handoff note format that makes the next session a cold start with no cost.

You end with: One harness step running without you: a hook, a scheduled run, or a CI gate.

You end with: A loop prompt with a stop condition and a state file.

You end with: Your workflow drawn as a graph, with the nodes that must not share context marked.

You end with: An incident-to-rule pipeline: the last bug you hit, converted into a rule that prevents its class.

You end with: A complete harness, assembled from every previous project.

You end with: An autonomous loop that runs unattended and stops on its own terms.

You end with: A multi-node graph with isolated contexts and a verified join.

You end with: A tool contract sheet: every agent-facing tool scored on what it does, how it is called, what it returns, and what a failure tells the model.

You end with: A context surface map: what lives in the durable log, what enters each model call, and what a summary is allowed to drop.

You end with: A side-effect ledger: every action that leaves your repository, its retry rule, and the stop reason you will record when it fails.

You end with: A scaffold ledger: each harness piece, the limit it bets on, what it costs, and the date you will test it again.

You end with: A running loop on your own repo — one state file, one exit condition — with at least one real unattended commit as proof.