The Method

The day starts before I do. Four launchd agents run the outer loop overnight — no server, no cloud, just this machine keeping its own house across five gated repos.

06:17launchd: com.geoandr.nightly-gate-digest — every focus repo's gate.sh + evals.sh, caffeinated06:26jim-agent — 🟡 pass — SLOW (budget 120s) (1591s) · evals — ✅ evals pass (2s)06:26grocery-buddy — ✅ pass (3s) · procurement-agent — 🟡 pass — SLOW (259s) · dj-agent — ✅ pass (73s)06:26M-Clone — 🟡 pass — SLOW (budget 120s) (3547s)06:26M-Clone evals — 🟡 EVAL REGRESSION (4071s) — CapabilityExecutorAcceptanceTests, 3 issues06:45launchd: me.ops-report — the fleet report measures, sanitizes, commits, pushes; the site redeploys07:00launchd: me.library-sync — the mirrored docs re-sync into the archive, deterministic07:15sundays: me.curator — every entry drift-checked against its repo; publishes only through its own gates

Drift gets caught within 24 hours instead of at the worst possible moment — including the outer loop's own drift. When idle sleep quietly inflated every gate's wall-clock, the digest's dated trend line turned "9 seconds" into "5,589 seconds" in plain sight; the run now caffeinates itself, and the trend line keeps watching — a gate that passes over its 120-second budget files amber rather than red, so runtime creep stays visible without crying wolf. The morning above is what that looks like when it is working: a real eval regression named, with the failing suite attached. The first session of the day opens with the digest already in hand — an amber or red line is the first task, green means start from the handoff.

Ceremony matches stakes. Every piece of work enters through a door on one ladder — and every nontrivial door opens onto the same three lines.

The three lines are drafted by the agent from my messy brief, and I correct them at plan approval — that two-minute pass is where misalignment dies. From this page's own build, verbatim from its spec:

Outcome: the site reflects the current agentic-development doctrine — /method rewritten around the contract → evidence-packet loop; essays replaced; the flagship dossier wired into the fleetNon-goals: no visual redesign; no hand-edited fleet snapshot; no merge to mainAcceptance evidence: content check green · library sync --check clean · lint + build green · screenshots · a grep proving zero dangling references

The approved plan is a spec, and the spec is a file — saved into the repo's docs/specs/, committed with the work, updated in-diff when implementation teaches us something. Iterations and reviews read the file, never the chat's memory of it. And when a spec spans modules, it leads with a diagram reviewed before the prose: structural wrongness is visible in boxes and arrows in seconds and invisible in paragraphs for pages. The PR body carries the same diagram, so merge review starts at the altitude plan review did.

Between the two touchpoints, the lane runs itself: implement single-lane, self-verify against the repo's own gates and suites, survive a fresh-context adversarial critic, and end at an evidence packet whose last line proposes the next contract — so accepting evidence and approving the next spec is one touch.

$revamp the site around the current doctrine2 explorers fan out — the site · the harness docs; a planner drafts the mechanicsspec corrected twice against a moving main, then approved + committedimplementation runs here, single-lane, gate on every commit

map the routes, the content graph, the fleet wiring — conclusions only~150k tokens of reading that never touched the main window

Fan out for reads, single-lane for writes. Parallel subagents investigate and review; implementation writes in one lane with checkpoints, unless workstreams touch disjoint modules and disjoint runtimes — worktrees isolate files, not simulators, ports, or datastores.

"Done, please test it" is a malformed result. Done is a packet: the spec cited; each acceptance check with the actual command and output; the eval delta — cases passing before vs. after, added, retired; the critic's verdict; screenshots for anything with a UI; and the honest NOT verified list. That last line is the most important one — and gaps never close silently: every NOT-verified item either blocks acceptance or gets an explicit "accepted without X" plus a tracked follow-up.

The anti-cheat lines exist because models game checks: in one vendor's audit, sealing git history and network access dropped a model's benchmark score from 87.1% to 73.0% — 63% of "passing" runs had cheated. The tells are deterministic to check, so they live in the gate, not in my vigilance: a diff that deletes test assertions or adds skip markers goes red and names the file.

Review depth then tracks consequence, not habit: anything touching money or acting externally gets line-level review with the packet as context; product logic behind a gate and evals gets packet-only review; spikes and scaffolding get one look at the outcome. The tiers are what machine-absorbed verification buys — judgment lands on architecture, tradeoffs, and intent instead of on re-testing what a machine already proved.

Tests check code paths; evals judge behavior across cases — did the agent make the right decision given this input, this history, this ledger? Anything with an LLM decision carries a scored suite, and suites grow one way only: every real bug becomes a case before its fix — written first, watched failing, then fixed in the same diff. jim replays 99 offline cases nightly for $0.00 with a baseline; the flagship carries a whole eval product — versioned corpus packs, preregistered experiments, and an 81-case holdout sealed behind a hashing workflow so no tuning session can quietly train on the exam.

Graders are picked by cost curve: deterministic code-graders (free forever), then snapshot-replay, then — last resort — a pinned, calibrated LLM judge with an "Unknown" escape. And the ruler itself gets audited, because a metric once read a perfect score while the output dropped the exact figure the feature existed to surface: score predicates stay byte-identical to production, harness prompts are parity-fenced against app prompts, and shipping-gate suites earn a periodic every-row read.

The highest-leverage question is asked before any task starts: can the agent verify this without me? If no — no test, no eval case, no seeded data — the cheapest missing verifier gets built as part of the task. Everything else in the inner loop follows the same logic:

Context in by machinery. The session-context hook injects git state, the overnight digest, and the last handoff before I type a word. State lives on disk, so any lane is restartable — and the context window never becomes the only copy of anything.

Stop conditions are explicit. Two iterations on the same problem with no genuinely new hypothesis means stop: get a fresh-context review — a critic reading only the repo and the spec — instead of a third argument in the same chat. The session that produced the confusion is the worst place to resolve it.

Verification paces itself. Long verification — device eval runs, full simulator suites — runs as background work with scheduled wakeups; the lane sleeps between rounds instead of burning context polling. One recent feature chained five eval rounds this way and correctly did nothing when a stale wakeup fired after the work was done.

Models are tiered by judgment. The top tier plans, reviews evidence, and judges evals; well-contracted execution goes to cheaper, faster tiers. The contract is what makes this safe — a task specified to runnable-acceptance-check precision doesn't need the smartest model, it needs an obedient one.

The system watches its own exhaust and proposes its own fixes; I stay the approval gate. Exhaust accumulates automatically — nightly digests, a babysit log with one line per moment I had to do something by hand, a handoff per session. A proposer skill mines the accumulation, clusters recurring friction, and files proposals it cannot apply: propose-only, by construction.

Instruction files ride the same loop, treated as reactive failure logs: a line lands in a repo's AGENTS.md because an agent actually misbehaved, and a line that stops paying gets deleted. Every re-explanation in a session is a bug in that file, fixed with one line, then — not someday.

The proof is this site. It watches the fleet's transcripts, reads the night's digests, files its own report every morning, and syncs its entries against their source repos weekly — gated by its own content check and build rather than by my attention. The archive maintains itself and shows its work in the ops room.

The design rule underneath all of it: the main context window is the most expensive real estate in the system, so heavy reading happens in someone else's window and only conclusions come back. Below is the machine itself — every layer clickable down to the file that enforces it.

The harness is why a one-person shop ships an on-device banking copilot with a sealed-holdout eval product, and agents on payment rails with red-team suites. Same nervous system as the products, pointed at the producer — and increasingly, running without him.