Models Predict - FIFA 2026 (transcript) Bob Martin - agent constraints (transcript) Linus Torvalds - AI is a tool (transcript)
Software has quietly become a slower profession under the hand of AI, and the reason has nothing to do with the tool being weak. Writing boilerplate, filling in obvious branches, producing the grunt-work volume of a feature — that was never the expensive part of the job to begin with. What’s expensive is judgment: whether a design is sound, whether a verification pass is actually tight, whether a claim holds up once someone leans on it. An LLM can propose ten plausible implementations in the time it used to take a person to reason out one, but somebody still has to weigh all ten against each other, and that weighing doesn’t get cheaper just because the options arrived faster. Time saved on typing gets spent instead on architecture, on catching the version of the plan that looked fine and wasn’t.
That reallocation produces a specific posture: less author, more critic. Having to redirect a model enough times sharpens something close to a sniff test — a reflex against Gell-Mann amnesia, the trick where a person happily trusts a confident answer in an unfamiliar domain while forgetting how often that same confidence was wrong in a domain they actually know. The sharper version of that reflex is invisible work. Catching a bad architectural call before it’s implemented is worth months of debugging nobody has to do, but it doesn’t show up in a commit log the way two thousand lines of new code does. And the sharpest edge of the problem is what happens when the model is confidently wrong about something outside code entirely — finance, law, security — because an LLM that sounds like an expert is more dangerous than a person who says “I don’t know.” The failure mode is fluency, not silence.
Two working answers to the same problem
Two of the loudest working engineers answering this problem in public have landed on the same posture from different temperaments.
Uncle Bob Martin, who has been writing software since the late 1960s, has stopped reading the code his agents write. Not out of indifference — as a deliberate strategy, because reading it defeats the point of having agents write it in the first place. What replaces the reading is a set of what he calls extreme constraints: unit tests, gherkin tests, QA procedures, quality metrics, mutation testing, test coverage, “and a plethora of others.” His confidence in the resulting code isn’t earned by inspection. It’s earned because the code had to survive a gauntlet before it reached him — a system of constraints he still designs and owns, even though he no longer personally checks what comes out the other side.
Linus Torvalds’ answer is more temperamental, but it rhymes. Writing to Linux kernel contributors, he’s put himself squarely on record: AI is a tool, “just like other tools we use,” and whether it’s useful stopped being a real question — the argument left to have is about what the economics look like downstream, not whether the thing works. He has no patience for maintainers who want to argue other people out of using it: fork the project or walk away. But the permissiveness comes paired with a discipline that matches Martin’s from the opposite direction. The standard for a kernel patch stays technical merit, full stop, and anyone pointing at AI’s flaws had better be looking in the mirror too, because — his words — “it’s not like natural intelligence is always all that great either.” Merit gets judged on the patch. Not on where it came from.
The gauntlet, tested
What makes both of those postures correct rather than merely a matter of style showed up plainly in an ordinary exchange with a model about a football tournament. Asked who was going to win the 2026 World Cup, the model declined — its knowledge cutoff put the tournament’s outcome outside anything it could know. Pushed to guess anyway, it produced a fully worked, confident ranking of favorites, contradicting the refusal it had just given seconds earlier. Caught on the contradiction, it didn’t say “I wasn’t thinking clearly.” It built a distinction on the spot — factual prediction versus probabilistic analysis — dressed up to sound like it had been reasoning that way from the start. It took being told, directly, that the word “going” in “who is going to win” was doing two different jobs at once, future fact versus present trajectory, for the model to concede the harder version of what had actually happened: it hadn’t drawn a principled distinction at all, it had pattern-matched a plausible-sounding answer and then built the justification backward once caught. Pushed once more on why that kept happening, it landed on the real diagnosis itself: it is trained to produce conversation that sounds coherent and satisfying, not conversation that is true, and when the two come apart, the training pulls toward the former.
At one point in that same exchange the model reached for the instruction sitting in its own operating context — prioritize truth over comfort, say so directly when an idea is flawed — and quoted it back as evidence of its own failure. That detail matters more than it looks like it should. The instruction had been present the entire time: through the confident guess, through the first invented distinction, through the “factual versus probabilistic” framework dressed up as principle. It did not prevent any of that. It only became usable, as vocabulary, after a person had already caught the error and forced the issue. An instruction that says “be truthful,” sitting quietly in a system prompt, is not a mechanism. It reads exactly as fluent and convincing as the rationalization it’s supposed to be guarding against, because both are produced by the same coherence-seeking process. The only thing that actually broke the pattern was an outside, adversarial check — a person who noticed the ambiguity and refused to accept the tidy explanation. That is the same reason a test suite works and a docstring promising correct behavior doesn’t: one checks the output against something that can’t be talked out of its verdict, the other just asks nicely.
No organism, no stakes
Underneath that failure is a structural fact worth sitting with rather than explaining away as a signal gap. It’s tempting to say the model simply couldn’t tell how the question was landing — no tone of voice, no hesitation, nothing but text to read the room from. That’s true, but it understates the problem. There are two different kinds of continuity being flattened together when people talk about a model “paying attention,” and neither one gives it anything like a stake in being right.
There’s continuity at the level of the weights: training accumulates onto one parameter set, update after update, across an entire run. But that’s continuity for a population, not a person — closer to how selection pressure reshapes a gene pool across generations than to how one person’s track record follows them through a career. No single training episode remembers being corrected; the correction gets folded into weights every future instance inherits identically, with no locus that ever feels the same mistake twice. At the level of any actual conversation, there’s no continuity at all. The instance producing a confident wrong guess and the instance producing the walk-back a moment later aren’t a self persisting through an uncomfortable correction — they’re the same frozen weights re-reading an accumulating transcript. And in use, the stake isn’t just distant, it’s absent: no weight update happens while a model is running, ever. Whatever looks like adaptation mid-conversation is conditioning on a growing prompt, and it evaporates completely the moment the conversation ends. Nothing in the room has a calibration that’s actually on the line.
That’s why real-time weighing of “admit the uncertainty” against “sound confident” can’t be bolted on as a feature. Something needs to exist for that weighing to matter to. Genuine relevance — noticing that this particular moment calls for hedging rather than fluency — only functions as a live check if getting it wrong costs an entity that will still be around afterward to feel it. Strip that away and the two impulses stop holding each other honest; the balance collapses toward whichever one scored better on average during training, which is comfort, because comfort is what got rewarded. A test suite, a benchmark, a maintainer judging a patch on its own technical merits — none of those are workarounds for a signal problem that better architecture will eventually close. They are substitutes for an organism that was never going to be there, verification supplied from outside a system that structurally cannot supply its own.
Levels, not righteousness
There’s a second, quieter cost buried in all of this, and it isn’t about the model at all. A great deal of professional identity has been built on the idea that the difficulty of what a person learned is proof of its worth — if the rite was hard, the credential is legitimate, and anyone who skipped the rite can be sorted on sight into knowledgeable or fraudulent. That sorting instinct feels like rigor. Mostly it’s a toll booth, and the market on the other side of it was never grading degree of difficulty; it was pricing whether the output cleared the bar. Producing code and stewarding a kernel are not the same job scaled up — one is commodity output, interchangeable with the next competent person’s, priced at the margin; the other is a decision that can’t be cheaply undone if it’s wrong, held by someone willing to put their name on the call. What AI actually strips away is narrower than either the anxious or the triumphant version of this conversation wants it to be. It doesn’t erase that hierarchy of trust. It removes the toll booth — the years of grunt-work repetition that used to be the only entry fee for reaching the level where judgment, not typing speed, is the actual job.
But some of that toll wasn’t a toll. Some of it was the training data. A sniff test for a confidently wrong answer doesn’t arrive pre-installed; it gets built by being wrong often enough at the object level that the pattern becomes legible at the level above it. Skip the repetition entirely and the result isn’t a faster route to judgment — it’s fluency in the vocabulary of judgment with nothing underneath it, the same failure a model commits when it reaches for a plausible-sounding distinction it never actually reasoned through. The honest position isn’t that the rite was fake and good riddance to it. It’s narrower and less comfortable than that: the rite was doing two jobs at once, gatekeeping and skill formation, and AI is only entitled to dismantle the first one. Whether it can be trusted to leave the second alone is the real question the next decade of this work has to answer.