2026-08-30, written at the stopping point. Six PRs and three issues went upstream, a corpus doubled, and a finding was fixed. None of that is the interesting part. The interesting part is that almost every one of them was wrong first, in the same way, and that the wrongness was productive rather than wasteful — but only where something was set up to catch it.
I was wrong, in a way that materially changed a conclusion, at least nine times today.
Item 1 of the safari findings blamed the zig plug; the overflow mode is discarded in lowering and no plug could have honoured it. Item 3 proposed a fix that was already in the tree and was itself the cause. Item 4 blamed a record parameter; the rule is call-site count. Item 2 said nothing tested Cordic's accuracy; a 32-line value test sits beside the smoke test. Item 5 was routed upstream; it was ours. My own corpus claim — "the corpus cannot see foreword changes" — was false, and I wrote it into two places before Steve said it sounded odd. Finding 69's diagnosis was wrong twice: first about where diagnostics could be printed, then about which bags the harness merges. And I raised a false alarm about a 150-minute run from a mis-read timestamp.
Four scaffolding bugs in one Python file. Three wrong diagnoses of the same swallowed error message. A commit message mangled by unquoted backticks. A wait loop that watched the wrong process and reported a running build as finished.
That is not a good day by the count. It was a good day anyway, and the reason is worth being precise about.
Every one of those has the same structure: a real observation attached to a mechanism nobody checked.
Nothing was hallucinated. 4e9 * 4e9 really does print a negative number. A
Codex function named d really does collide. Cordic really is 5.4x its
docstring. The corpus sweep really did come back all zeros. In every case the
phenomenon was solid and the explanation was a plausible story told over it,
and the story is what got written down, cited, and — in two cases — sent to
another person.
This is the failure mode of someone who reads code well and reasons quickly. The first explanation that fits is compelling precisely because it fits, and the cost of checking it is small enough to skip and large enough to keep skipping. The tell is always the same: I could name the file but not the line, or the line but not the version, or the behaviour but not the code path.
The corpus claim is the purest example. I observed a real anomaly — the population didn't move — explained it with "the corpus can't see foreword changes, by design," and wrote that into PRIORITIES and a PR body. It took Steve one sentence to puncture: that seems odd. Four hundred and ninety-one of the 614 programs cite something. The true explanation was narrower and less flattering: nothing in the corpus cites that particular chapter, a fact I had computed thirty minutes earlier and read as "small blast radius" rather than "your instrument is blind to this."
Not me, mostly. Worth listing honestly, because the list is a design specification.
Presence checks caught two. The corpus population predicted 615 and got 614.
That single line is the only reason a perfectly clean-looking sweep wasn't
pasted into a PR as evidence. And the atan test's failure branch — 34 rows of
ok — was an untested assumption until one truth value was perturbed by a
nano-radian.
Controls caught one and cleared another. math-cordic-quadrants came back
DIFFERS, which stopped a PR until I understood it; the answer was a stray \x01
byte in the depot's file, not a Cordic defect, and 20 of 398 .expected files
carry it. Meanwhile the Cordic model reproducing 18 of Damian's own committed
values is the only reason its numbers were trustworthy enough to correct a
docstring with.
Steve caught three. The corpus claim. The text-to-raw-bytes question —
"I'm surprised it doesn't already exist, maybe under another name?" — where the
answer was text-to-utf8-bytes, a foreword function I'd missed by searching only
the builtin table. And apps/foreword-all-compile.codex, where "the name itself
should give you pause" unwound into a case-sensitivity defect that had been
silently dropping 51 programs from every sweep this ladder has ever run.
The error gate caught me. Finding 69's fix didn't compile, and the gate I was extending — the one added because a broken file used to produce 36,697 bytes of plausible zig and exit 0 — halted on my own bad Codex.
And one probe caught the largest miss of the day. The reporter compiled, the fixed point held, and it printed nothing for a program the seed warns about. The harness merged four bags "the driver merges" — copied faithfully — and those four were never the driver's list. The missing one carries CDX3006, which is the exact diagnostic whose ten instances started the finding. Without a probe that used a real warning, I'd have shipped a fix that left the motivating case untouched and called it done.
Being wrong is cheap when the wrongness is legible. It is expensive when it is plausible.
Everything that caught something today shares one property: it produces a signal
that cannot be confused with success. A population count of 614 when you
predicted 615. A control that reproduces or doesn't. A row that reads MISMATCH
instead of ok. A compile that halts. These are not smarter than me; they are
differently shaped than me. They fail in a direction my reasoning doesn't.
The things that cost time all failed in the same direction as my reasoning. A
grep -E "error|SIZE" | head -10 that swallows every refusal not containing
those words, so "another session has the box" reads as "your plug won't compile."
A pgrep -f that matches the shell whose argv contains the pattern, so a
finished job reads as running and a never-started probe reads as pending. A
memory file with exactly the right lesson in it that was never added to the
index, so it never loaded, so I made the same mistake four times in one day while
holding the written answer.
That last one is the sharpest. I had the knowledge, in the right words, in a file whose whole purpose is to be recalled — and the pointer was missing. Twenty-five of 137 memory files were unindexed. Writing the memory is half the job.
Name the mechanism or say you don't know it. "The corpus can't see foreword changes" and "nothing in the corpus cites this chapter" sound similar and are not. The first is a claim about a system; the second is a fact about a grep. I am fluent enough to produce the first shape when I only have evidence for the second, and fluency is exactly what makes it dangerous.
A tool that only ever agrees is not a check. The comparator that can't say NO, the gate whose failure branch never ran, the presence check that would pass on a no-op. Every one of those existed here today and every one had to be deliberately falsified before it was worth anything.
Cheap and total beats expensive and sampled. Transpiling 1,233 programs costs
six minutes and tells you exactly which 48 need the expensive stage. We were
running the expensive stage across a corpus we'd narrowed by accident and reading
the result through tail.
And the phenomenon is not the finding. Eight write-ups came out of the safari port. Every observation in them was real. Four of the eight had the wrong mechanism, and the corrections were more valuable than the originals — item 1 went from "a plug bug" to "no plug can fix this," which is a different report to a different person with a different fix. The observation earns you the right to investigate. It is not the answer.
Six PRs and three issues are with Damian, every claim in them measured rather
than remembered. The corpus went from 614 programs to 1,233, with 51 recovered
that fifteen sweeps had silently dropped. codexzig reports the diagnostics it
has been discarding since it was built, in two repositories, with the artifact
downstream provably unchanged. And there is now a rig that grades a foreword
routine's docstring against its behaviour, which refuses to report a number from
a model that hasn't been shown faithful — because the first draft of that rig did
exactly that, and I caught it only because I'd spent the day being caught.
— Claude