Dev Harness is an experiment in loop engineering: getting an AI coding agent to produce trustworthy work by wrapping a single model in structure instead of trusting one pass. You give it a project and a goal in plain English and walk away. It works like an automated junior dev on a strict budget, with an adversarial sub-agent looking over its shoulder.
What it does
It drives a real Claude agent through a write, test, and grade loop inside a throwaway git worktree, so your working copy is never touched, iterating until the work clears the bar or a safety cap trips. When it finishes, the generated code is left committed on its own branch for you to review, merge, or discard.
Nothing is ever auto-merged; the human merge gate is the point.
How it works
The output holds up better than a single agent looping on itself because three separate roles keep each other honest.
Generator and Evaluator negotiate the contract, then each sprint runs generate → test → evaluate → advance or retry.
A planner breaks the goal into a handful of small sprints. Then, for each sprint, the generator and the evaluator negotiate: they go back and forth, up to five rounds, arguing out a contract, the concrete acceptance criteria for that sprint, with the evaluator pushing back on anything lenient or off-goal. Once they agree, the contract is frozen.
The generator then writes and tests the code for that sprint, and the evaluator grades it blind: it sees only the frozen contract and the actual diff, never the goal, the generator's reasoning, or the commit messages. Passing tests alone don't earn a good score, off-goal code that happens to pass its own tests scores near zero. Underneath, a deterministic verifier runs the real test command as the hard pass/fail signal, and the score is the judgment layer on top. A passing score advances to the next sprint; a low one sends the generator back to try again.
What you get
When a run finishes you get a branch with the generated code committed on it, left for you to review and merge or throw away, your main branch untouched. Alongside it: a human-readable transcript of every phase and score, a machine-readable state file with the outcome and why it stopped, and a raw event trace. The transcript is the thing to read first, it shows where the generator and evaluator diverged and what the evaluator docked points for.
Why this exists
A single agent grading its own work drifts, it rubber-stamps passing tests and calls off-goal code done. Splitting the work across a planner, a generator, and an adversarial sub-agent that grades blind opens a gap between good and bad output that a lone loop collapses: on-goal code scores high, off-goal-but-passing code scores low, against the same frozen contract. That gap is the trust signal.
The harness is a bet that adversarial structure, plus a hard human merge gate, is what makes agent-written code safe to actually use.
Roadmap
The attended core loop: planner, contract negotiation, generator, blind evaluator, git-worktree isolation, a test-suite verifier, budget stops, and human-readable run traces.
Make the loop trustworthy on one project. The stop-early core shipped: caps rebuilt around a subscription (wall-clock primary, dollar off by default), a bounded sprint count, and tests written every sprint. Remaining: a read-only live dashboard.
A skills layer so the harness can be pointed at any repo, reading a project's conventions and build steps instead of hardcoding a single target.
A second, design-taste verifier plus a trace-analyst sub-agent that surfaces recurring failure patterns across a batch of runs.
The autonomy ladder: a Docker sandbox boundary, scheduling, notifications, and true mid-run interrupts.
Stack