| name | eval-harness |
| description | Build a repeatable eval loop that grades agent output with an LLM judge, so prompt/skill changes get scored against a baseline instead of eyeballed. Reuses loopkit's verifier subagent as the grader — do not build a new one. |
| when_to_use | tuning a prompt, changing a skill, comparing two models, regression-testing a workflow, "does this actually work better?" |
Eval Harness
Every prompt tweak in a long-running agent looks like an improvement in the moment. The only way to know is a graded run against fixed inputs. Loopkit already ships .claude/agents/verifier.md — that is your grader. Do not rebuild it.
The three-stage loop
inputs.jsonl → runner → outputs.jsonl → verifier (per row) → verdicts.jsonl → diff vs baseline
Each stage writes to disk. No stage holds the whole run in context.
Stage 1 — inputs.jsonl
One JSON object per row: {"id": "case-01", "input": "...", "expected": "..."}.
- 20-100 cases is enough for a signal. More is nice, not required.
- Include known-hard cases, edge cases, and a couple of trivial ones as sanity anchors.
- Freeze the file. Rev the eval with a suffix (
inputs-v2.jsonl) when you change it. Never edit in place — you lose the baseline.
Stage 2 — runner
A dumb loop: for each row, call the model with the current prompt/skill, capture output, write {"id": ..., "output": ...} to outputs.jsonl. No grading here — just capture.
- Same temperature every run (usually 0 for evals).
- Same seed / model version.
- Log the git SHA of the prompt/skill under test in the file header.
If the runner is smart it will bias the eval. Keep it dumb.
Stage 3 — verifier
Fan out one subagent per row (see subagent-fanout). Each gets:
- The input.
- The expected output (or spec).
- The actual output.
- The verifier system prompt from
.claude/agents/verifier.md.
Verifier returns strict JSON: {"pass": bool, "why": "..."}. Collect into verdicts.jsonl.
Diff vs baseline
Two runs of the same eval on two prompt versions → compare pass rates per case. What matters:
- Overall pass rate — the headline.
- Regressions — cases that were green and went red. These block ship.
- New passes — cases that were red and went green. These justify ship.
- Flappy cases — inconsistent across reruns. Investigate; may be genuine model nondeterminism or a bad case.
A change that raises the mean but adds regressions is usually a loss — the new failures are cases you already knew worked.
Red flags
- Grader is the same model that produced the output, with the same prompt. Self-grading is lenient. Use a different persona at minimum; ideally a different model tier.
- Eval passes 100% on day one. The cases are too easy, or the grader is a rubber stamp. Add adversarial cases.
- Eval takes >30 minutes. Fan out. A serial 100-case eval is a serial 100-case bottleneck.
- Grader sees your prompt under test. It will grade what you wanted, not what happened. Feed it only spec + input + output.
- Baseline lost. Without baseline, "improvement" is vibes. Commit
verdicts.jsonl to git.
When NOT to do this
- One-off script — build a checklist, not a harness.
- Prompt that changes daily and won't stabilize — evals need a fixed target.
- Task where "correct" isn't checkable (open-ended creative writing) — use human eval or a rubric-based grader, not pass/fail.
The verifier is already yours. The harness is 100 lines of glue around it.
