Published on: July 4, 2026
Ready to accelerate your breakthrough? Send yourself an Un-Robocall™ • Get transcript when logged in
Send Strategic Nudge (30 seconds)Green in-lane · amber a little out · red drift. Every panel is a real commit, byte-identical on recompute. Tap any panel to open its shareable receipt.
We believe you should never buy a measuring instrument from someone who won't hold it against their own work first. So here is ours, held against ours: this weekend we wrote a reinsurance pitch, ran it through the exact same drift gate we're asking carriers to run their AI agents through — and it failed, twice, and refused to let us send it. Not a typo checker. A gate that measures whether what the words mean to a reader matches what we intended them to mean, and blocks the send when they diverge. It caught our own copy drifting off-target before it reached a single actuary's desk. That failure is not the embarrassing part of this story. It is the product.
You have written something you were certain was clear, sent it, and watched it land as the opposite of what you meant. The gap between what you intended and what the reader received is invisible to you — you already know what you meant, so your eyes fill it in. That same blindness is exactly why an AI agent can do beautiful work in the wrong place and every review waves it through: the author, human or model, can't see its own drift. The only thing that catches it is a reader who doesn't already know the answer. That is what a drift gate is — a stranger's eyes, made mechanical and un-skippable.
Here's the mechanism you can use. A small, local, deliberately weaker AI reads the draft cold, one paragraph at a time, playing the exact buyer it's aimed at — and says out loud what it actually understood. Then a stronger model grades that understanding against the intended takeaway, and any paragraph where the reader missed the point gets rewritten and re-read until it lands. Why the weaker reader? Because a strong model papers over muddy writing — it gap-fills with its own intelligence and "gets it" anyway, giving you a false pass. A weaker-but-knowledgeable reader only understands you if the prose itself did the work. If it gets it, you cleared a higher bar, not a lower one. The gate is that reader, and it does not let you skip it.
This is the same move as the whole product, pointed at prose instead of code. We can't decide whether your writing is "good" any more than we can decide whether your code is bug-free — that's undecidable. But we can decide, mechanically, whether a reader landed on the meaning you aimed at. Placement is decidable; quality isn't. So we gate on placement.
Two catches, both real, both invisible to us. First — and let's be precise, because this is the exact spot where "editing" could mean "spin": the number never moved. A calibrated breach rate of 13.8% is 13.8% before and after; it's a low-single-teens frequency that is genuinely favorable in this line of risk. What our prose failed to do was say so. We'd stated the figure and assumed a reader would know a low rate is good news; the cold reader didn't, and read it as "concerning." We did not touch the number — we added the one plain sentence the prose was missing, that a rate this low is one you write against rather than fear. The next read came back "reassuring." The fix was honesty about what the figure already meant, not a nicer figure. Second: a paragraph about setting an industry standard made the reader worry about vendor lock-in — the exact objection that kills a reinsurance deal, and one we'd simply never addressed. We added a true sentence: it's an open command anyone can run, so there's no black box to keep renting. The next read: "not locked into a vendor — intriguing." Three passes, and the stranger was won — by adding facts the prose had left out, never by bending one.
The gate does not prove the pitch will win the deal — persuasion is human and undecidable, and we don't claim otherwise. It proves something narrower and more useful: that the meaning we intended is the meaning a fair reader received. A believable read is not a signed contract; it's the removal of the one failure mode we can actually remove — transmitting a payload that means something other than what we thought it meant. Everything past that is the market's call, outside the fence, where it belongs.
What is solid: the gate fired on a real payload we wanted to send, and it would not clear until the reception matched the intent. There was no override, no "ship it, it's close enough." The same discipline that makes the on-commit receipt refuse to fake a non-empty panel made the outreach refuse to send a misread number. An instrument that will block its own maker's revenue email until the meaning lands is an instrument you can believe will block your agent when it drifts — because it already proved it doesn't make exceptions for the people who built it.
If you're evaluating anyone selling AI safety or assurance, this is the question worth asking them: did you run your own claims through it first, and did it ever tell you no? If the answer is no, the instrument has never been tested against the one party most motivated to skip it — its owner. Ours told us no, twice, this weekend, and we have the reader's own words to show it. What that buys you is not our polish; it's the confidence that the same gate, and the same one-command recompute, will govern your agents with exactly as little mercy as it governed our sales pitch. You don't get a vendor's promise. You get a governor that has already refused its maker.
Here is the most useful evidence, because it's the objection you're probably already forming. When we drafted the section above, the gate flagged a reaction we didn't expect: reading the 13.8% rewrite — "concerning" on the first pass, "reassuringly low" after — the cold reader called it spin. Us changing words until a number sounded better. That reaction is fair, and we're not going to argue you out of it. We're going to hand you the thing that settles it: the number isn't ours to spin. npx prove <sha> re-derives the exact lattice coordinate, the σ, and the drift distance behind every claim here on your machine — 13.8% comes back 13.8%, or it doesn't come back at all. We can make prose sound better; we cannot make the recompute return a different coordinate. The gate surfaced your doubt about the words; the recompute answers it below the words, where language can't reach. (The vendor-lock-in fix, for contrast, needed no such defense — that one was just a true fact we'd left out: it's an open command, so there's no black box to keep renting.) And the deeper claim under the whole thing is itself recomputable, not rhetorical: every commit that built this ships a signed receipt, and npx prove <sha> re-derives its exact lattice coordinate on your own machine — the same "does the meaning land where it should" test, run on code instead of copy. The gate on the prose and the receipt on the code are the same instrument — the same one we described in The Shape of the Technology.
The lesson we keep relearning: the weaker reader is the stricter bar. Every time we were tempted to trust our own grade and ship, the deliberately-weaker reader found the exact spot where the prose hadn't done its job. Grade yourself with the model that can't gap-fill for you.
Two things, both yours. First, steal the method: before your next important send, have a weaker model read it cold as the recipient and tell you what it understood — then fix every place it missed your point. It costs minutes and it catches the drift your own eyes can't. Second, if you want to see the code version of the same idea, read the pixel — the claim that competence is a coordinate you can be in or out of — and know that every receipt behind it is one you can recompute rather than trust. An instrument that refuses its own maker is the only kind worth pointing at your agents.
