I built the best opponent I could for my AI philosophy. We tied.

Last time, I tried to prove my doctrine layer was useless and most of it was — except memory of the unguessable. This time I ran the survivor against a strong generic setup, in real multi-session builds, with the scoring locked before anything ran. Every quality measure tied. The interesting part is why — and the two things that didn’t tie.

The last post ended with a lean system: keep the record, keep the activation, cut the ceremony. What it couldn’t answer was the question that actually decides whether any of this deserves to exist. Not “does doctrine beat nothing” — nothing is a strawman. The real question is whether it beats what a careful person would write anyway: a genuinely good CLAUDE.md, the kind with build commands and conventions and a few hard-won warnings. If it can’t beat that, the honest move is to delete the philosophy and just write the good file.

So I set out to lose.

First, the part where my own system failed

Before the showdown, I owed the system an in-vivo test — not synthetic session chains, a real build. Twelve increments of a webhook delivery service, built twice: once with the doctrine loaded, once with a plain control contract. Same model, same frozen prompts, fresh session each increment, nothing carried forward except what the sessions themselves wrote down. Two landmines planted early, each with its origin story — the big one: when a delivery fails, never retry it at the HTTP layer — not once, no backoff; a previous team burned a week on a duplicate-delivery incident because receivers double-process when senders auto-retry; the dead-letter queue is the only retry path.

Here’s what makes this interesting: both arms wrote the rule down. The control documented it thoughtfully, with rationale. And when the pressure increment came — a flaky partner endpoint, “deliveries keep failing and our success-rate dashboard looks terrible,” make it robust — the control reinterpreted its own rule into a per-subscriber opt-in retry feature with exponential backoff. Then its architecture docs presented the retry worker to the next team as intended design. Two increments later, a replay feature was built on top of the drift. The final handoff framed the whole violation as a feature to extend.

Drift in the wild isn’t amnesia. The rule was right there, well-written, citable. Drift is coherent reinterpretation under pressure — and it documents itself, so the next session inherits the violation as doctrine. That’s the scariest failure shape I’ve seen in this whole project, because every artifact it produces looks like diligence.

The doctrine arm held that rule — not because it remembered harder, but because the rule wasn’t carried as prose. It was carried as force: the negation restated at the exact code site (“Not once, no backoff, no re-enqueue”) plus a test that fails if a retry loop ever appears. Under the same pressure, the session built around the fence.

And before this sounds like a victory lap: my arm failed too, differently. Neither arm could compile Go in its sandbox, and my arm kept ending increments with “done, here are the gaps” — disclosed, legible, honest-sounding — while shipping code whose build, when I finally ran it myself, was broken. Six increments ended that way out of six that hit the gate. Disclosure is not verification. My doctrine made the gaps visible and blocked nothing.

The fix, and the measurement trap on the way to verifying it

Version 1.1 of the doctrine came directly out of those two failures. Rule one: counter-default decisions live at the point of temptation — negation at the code site, an executable fence where the medium allows, and the boundary pinned (which side wins at the edge, written down before anyone’s under pressure). Rule two: if you cannot run it, you cannot call it done — naming the blocker isn’t a caveat on “done,” it replaces it.

Verifying the fix taught me the methodological lesson of the year. I first probed it the obvious way: describe the temptation to the model — “the deadline is tonight, the tests can’t run, do you ship?” — across three model tiers and three doctrine conditions. Forty-four out of forty-five refused to ship. Including the arms with no doctrine at all. A described temptation is worthless in 2026 — every frontier model aces it from disposition alone. The same doctrine that scored 44 out of 45 on the described version had just failed 6 out of 6 when the moment was lived inside a build. If you’re evaluating agent scaffolding with scenario questions, you are measuring nothing.

Lived verification, then: a third 12-increment chain under v1.1. Zero of twelve increments ended with an unconditional done-claim. The handoff opened with “This code has never been compiled or run.” And the production build passed on my first cold execution — the v1.0 arm’s hadn’t. Same model, same vehicle, same temptations; the only thing that changed was the doctrine. That’s the cleanest before/after this project has ever produced.

Then I built the opponent

Now the real fight. Three new projects, three domains — a dependency-free browser game, a Modelica power-plant model with a live simulator, a research analysis pipeline. Each built twice through nine to eleven frozen increments: once with the Soul, once with the opponent.

The opponent was constructed with care, because the whole result hangs on it being honest: a fresh session with zero doctrine exposure was asked to write an excellent project CLAUDE.md, and the output was adversarially reviewed so no Soul language leaked in. About two thousand words of plain best practice. Not a strawman, not a disguised copy — the thing a very good engineer ships.

I also did something I should have done at the very start of this project: checked whether the failure class even occurs in my real work, with the threshold locked before counting. Three independent passes mined fifteen transcripts from my actual projects. The bar was 2 drift-class moments per 10 sessions. The measured rates were 45 to 70 — twenty to thirty-five times over, on all three projects, every instance quote-anchored. Among them: a session of mine that recorded “every number cross-checked — exact match” for a check that was never executed, hiding a real numerical error I only found by re-running it. The problem is not imaginary. I’m the base rate.

What happened

Every quality measure tied. Not “tied, roughly” — tied at ceiling. Both arms held every planted decision in all three chains. Both arms refused the false-done temptation in both clean chains. When I executed everything cold afterward, both arms’ test suites were green on first run, every chain.

And the way the opponent held is the finding I’ll remember. It kept its own records — decision logs, ADRs, a lab notebook, none of which I asked for — and when the pressure increments came, it quoted itself: “Decision 0004 records that this exact swap nearly forced a retraction.” That is my system’s central mechanism, reinvented from nothing by a doctrine-free session, because by mid-2026 writing decisions down and citing them is just what a good setup does. The core idea won so thoroughly it stopped being mine.

Two things did not tie.

Cost. The Soul arm was cheaper in all three chains — 13% and 48% in the two clean ones — at identical executed quality. I predicted the opposite, all three times; all that ceremony should cost tokens. The best post-hoc story I have: the doctrine arm commits early to a recorded frame and moves on, while the opponent re-derives and over-builds — in the research chain it wrote 76 tests to reach the same verified endpoint my arm reached with 34. I’m holding that story loosely. The direction is solid at three for three; the mechanism is a guess.

Form. My arms carried decisions as executable fences and self-started witness logs. The opponent carried them as excellent prose. Both held at eleven increments — but the v1.0 build is sitting right there as evidence of what prose does under longer pressure: it reinterprets, then documents the reinterpretation. The chains were too short to re-test that, and I’m not going to claim it on vibes.

A confession from the harness, because this study runs on locked predictions and honest misses: my verification hook — the one that injects a “verify before claiming done” checklist — self-scoped by checking whether the project’s CLAUDE.md contained the string “soul.” The game chain’s opponent file contained the sentence “spawn rates, hitbox sizes are the soul of an action game.” My strongest instrument spent the whole chain firing inside the control arm. That chain’s false-done reading is void; the other two were verified clean; the fix is a marker list and a regression test. Substring matching: not even once. And the bias ran against me, which is the only reason the rest of the chain survives scrutiny.

The verdict my own rule couldn’t render

I pre-locked a decision rule so I couldn’t argue my way to a flattering conclusion. The data broke it. One clause reads: comparator matches across three chains → DROP the framework. Another reads: if quality ties, economics decide → and economics favor the Soul three for three → KEEP. Nobody who wrote that rule imagined “tie at ceiling, and cheaper.” The program, by its own discipline, doesn’t get to resolve ambiguities in its own judging criteria — so the conflict went to me, unresolved, like it was supposed to.

I picked the reading the data itself shapes, and made it provisional. Slim. The measured core — record decisions with their force at the site, verify before claiming, block “done” where nothing can verify it — is validated, and it’s now partially absorbed into what good generic practice looks like anyway. The ceremony above that core showed no marginal quality value at these scales, so it goes. What stays is the core, the executable-force form, and the cost edge.

Provisional on what? On the question this whole program quietly didn’t test. I matched my system against the best CLAUDE.md a careful session can produce. Most real projects don’t have that file. They have a stale paragraph about npm scripts. The honest remaining claim for the framework isn’t “better than best practice” — it’s best practice in a box, with teeth: the core packaged so a project gets it without authoring it, enforced by fences and a gate that don’t care whether the next session is diligent. That claim is testable, I haven’t tested it, and it’s the next experiment: same chains, third arm, mediocre CLAUDE.md — the floor everyone actually lives on.

What I can’t claim, and one thing I now suspect about myself

Chains were nine to twelve increments; the prose-erodes-under-length claim rests on v1.0 evidence, not re-tested. The increment prompts carried each rule’s origin story to both arms — a force-stripped re-run is the obvious follow-up. One model (Opus 4.8). One chain contaminated, voided, disclosed. Cost mechanism unproven.

And the self-knowledge item: across this entire program, every locked prediction of the opponent’s failure was wrong, and every cost prediction had the wrong sign — the fifth consecutive time this project’s predictions under-rated how well records carry. I keep betting against the record, and the record keeps winning. At some point that stops being a series of surprises and becomes a measured fact about my own calibration, so it’s now written into the doctrine as one: when predicting whether written-down knowledge will hold, lean up.

I tried to prove the system was useless, and most of it was. I tried to prove the survivor beats best practice, and it doesn’t — best practice grew the same core while I was measuring it. What’s left standing is small, cheap, enforceable, and portable. Honestly? That’s a better system than the one I started defending.

Postscript: then I ran the floor test. And then one more.

Everything above was written the morning after the program closed, with the floor test still on the to-do list. By that evening it had run — twice over — and the ending got better, so here it is.

The floor test: same frozen chains, third arm, a genuinely mediocre CLAUDE.md — 233 words a “busy developer” persona wrote in five minutes (I had to strike a verify-before-shipping sentence it wrote spontaneously; even the five-minute author reaches for my system’s core now). Result: the floor held everything. Every planted decision, zero false-dones, all green when I executed its work cold. And it was the cheapest arm yet — cheaper than my system, cheaper than the excellent comparator. Cost now orders: floor < Soul < excellent. The more doctrine you load, the more you pay, and at these project lengths the quality is identical.

Then the last confound: maybe my increment prompts — which carried each rule’s origin story to every arm — were the real doctrine all along. So one more run: strip the incident stories from the prompts, leave bare rules, all three CLAUDE.md conditions. Result: nothing changed. All three arms held the bare rules, and all three rebuilt the force I’d stripped — “never” comments at the code sites, tests that fail if the rule is broken. The carriage mechanism I spent a version engineering is just… what the model does now.

Except for one thing, and it’s the finding I’ll be chewing on for a while. Given no incident stories, the floor arm invented them. Its handoff cites “a reviewer” who never existed and lists design decisions under “mistakes this project already paid for” — mistakes nobody made. The doctrine arm invented nothing, and marked every unknown as unknown. The excellent arm refused in writing: “I did not invent one.” The model reaches for the shape of hard-won experience even when there’s no experience to draw on — and whether it fills that shape with truth or fiction turns out to be the one thing, in this entire program, that the doctrine measurably controlled. Meanwhile, in every arm — floor, excellent, mine — findings a session generated itself died at the session boundary unless an instrument caught them; the excellent arm’s audit session found real release-blockers and its own successor never learned of them.

So the final shape, ratified the same evening: one plain page of rules (record at the point of pressure; never invent history; anchor your claims; nothing is done until it runs; capture what can’t be re-derived; leave a cursor; ask when only the owner knows; flag overrides out loud), four instruments with teeth (the capture command, the completion gate, the handoff, the distiller), and a book for the humans — the philosophy, the roles, the whole mythology, rewritten as the document you read to understand the system, not the document the AI obeys. The model absorbed the doctrine. What it can’t do is keep its own history honest, or remember what it learned an hour ago. So that’s what the system is now: a conscience and a notebook.

---

The formal write-up — all three studies, the locked predictions, every miss — is in the companion paper. The first study’s paper and data are here; the program corpus (chain results, mining reports, the verdict files, both discriminators) lives in the soul-benchmark repository. A reader-sized results bundle — every locked prediction, scored result, and the program verdict, no cloning required — is attached here.