The Constraint Was Never the Code
For weeks the through-line here has been displacement — who absorbs agent output, where the worker flees, whether every firm automating at once adds up to ruin. This week the material turns away from that macro question and toward something more intimate and more infrastructural at the same time. The pattern underneath is the same in every register: the thing AI is driving to zero, the cost of producing code, was never what was holding the system up. Strip it away and you find out what was — and some of it was load-bearing in ways no one priced.
When Production Is Free, the Frontier Moves
Start at the hackathon. Oscar built an AI agent into a rotary phone over a weekend — a Raspberry Pi wired into the bell ringer and the hangup switch, a warm Yorkshire voice on the line fielding requests like "play some music by artists who are alleged to be on the Epstein files." Neither he nor his teammate looked at a single line of code the entire 48 hours. His read on what that means for the form: a web app that would have been a feat two years ago "has now tumbled into mediocrity," so the moonshot has to move. He points it at hardware — turning a fax machine into a social network, a Game Boy Advance into a Bloomberg terminal, "a hubris manifest in a breadboard."
The interesting part isn't the unread code, which this newsletter has already filed under deferred comprehension. It's the relocation. When the expensive, finger-aching part of building dissolves, the constraint doesn't vanish — it moves to wherever the next scarcity lives, in Oscar's case the physical interface between an LLM and a fifty-year-old telephone. Cheap production reveals that production was never where the difficulty actually was. It was the rate-limiter standing in front of harder things, and removing it just exposes them.
The Friction Was a Rudder
That exposure is not always pleasant. Joe Masilotti spent years religiously tracking his time — client work in one bucket, side projects in another — and finally quit in 2026, calling it the most freeing thing he'd done. The friction was gone. With AI-assisted development on top of it, he could bounce between ideas the instant they sparked. And he describes the result with unusual honesty: "damn is my brain fragmented." The few seconds of admin friction that used to sit between an impulse and the work turned out to be doing something. "The friction I felt around picking one thing may have actually been beneficial. Perhaps it was actually helping me stay focused." He removed a tax and discovered it had been a rudder.
Sean Goedecke arrives at the same insight from the opposite direction — by prescribing the friction deliberately. His argument for doing nothing at work is that performance at tech companies is dominated by outlier events: unblocking an enterprise deal, catching an incident early, knowing the one obscure change a high-profile feature hinges on. All of them are time-dependent and none of them can be reached by grinding the backlog. "There are no points for effort in software development." So he runs at 80% utilization on purpose, because the engineer who is always fully loaded is too busy to notice the opportunity and too obviously occupied for a manager to tag in. Slack is not the absence of productivity; it is the precondition for the only kind that matters.
Put Masilotti and Goedecke together and the same claim appears in personal and professional dress. The binding constraint on a knowledge worker was never throughput. It was attention, timing, judgment about which of ten possible things is the one worth doing. AI obliterates the throughput constraint and leaves the real one fully intact — arguably worse, because the friction that used to ration attention is gone too. The bottleneck the prior editions located at the firm level, where absorbing agent output became its own category of work, runs straight down into the individual's afternoon.
Trust as the Attack Surface
There is a sharper edge to "production is free." If anyone can generate plausible code, identity, and history at no cost, then the scarce thing — the thing now worth attacking — is trust. Roman Imankulov got a LinkedIn message from a recruiter at a crypto startup asking him to review a repo and "check out the deprecated Node modules issue." The instruction was bait: npm install runs a prepare script, the prepare script runs the backdoor, and the backdoor — buried in 250 lines disguised as a test suite, a URL assembled from string fragments — executes whatever a remote server hands back. The recruiter's profile belonged to a real arts journalist who, once Roman played along, "instantly turned into an expert on npm and Node versions." The 39 commits were authored under the stolen name and email of a real developer who had never touched the repo.
Every layer was a borrowed signal: a borrowed identity to establish the recruiter, a borrowed commit history to establish the code, a fake startup to establish the context. The forgery is cheap now, which is exactly why it scales. What's worth dwelling on is the instrument Roman used to catch it. He spun up a throwaway VPS, cloned the repo there, and pointed an agent at it in read-only mode — --tools read,grep,find,ls — and it flagged the payload in seconds. "Reviewing the code with a read-only agent turned out more productive than reading it myself." The same class of tool that mass-produces untrusted code is also the cheapest way to verify untrusted code, provided you cage it correctly. The agent that writes the thing no one can trust is the agent that audits the thing no one can trust.
A year ago this distinction barely existed as a practice. Armin Ronacher's "We Can Just Measure Things" pointed an agent at his own codebase and used its measurable frustration — failed loops, repeated errors — as an objective proxy for project health. The agent as instrument, not author. Roman is that idea turned outward and weaponized: the same measurement, aimed not at your own code to improve it but at an adversary's to survive it. And it lands against the year-ago consensus that you cannot responsibly ship code you didn't read — Miguel Grinberg's position that "I'm always the responsible party for the code I produce," that review is slower than writing. Roman didn't read the backdoor. The agent did, and reading it manually is precisely how the trap catches a tired person on a rushed day. In twelve months the agent went from the thing you shouldn't trust to the thing you check trust with.
Trust, Liquidated From the Top
Scale that up and you get the week's loudest argument. The tech industry, in mrmarket's telling, "spent forty years accumulating a very specific kind of trust" — the Jobs-and-Woz image of the obsessive who wanted to be left alone with the work — and its leadership has discovered that trust can be converted into attention "at what looked like a great exchange rate." The exhibit is the Founders Fund Mafia video: Peter Thiel's firm producing a game show in which Sam Altman, Palmer Luckey, Bryan Johnson and a rotating cast play a party game about deception, filmed at the same bar as the 2007 PayPal gangster shoot. The mechanism the piece names is reality TV as a laundering technology — the format that took someone you'd keep at arm's length and made him a recurring, lovable guest in your living room until the strangeness wore off, now applied to the people holding the capital, the weapons contracts, and the line to the White House.
The problem with liquidating an illiquid asset, as the piece puts it, is that you don't learn the real price until you try to buy it back. Set that beside Roman. At the precise moment trust becomes the scarce asset under active attack from below — forged recruiters, stolen commit histories — the industry's most powerful figures are cashing theirs out from the top for viral attention. Both are spending the same reserve, and it doesn't refill.
This is also where the week's one genuinely cheerful argument belongs. Keyvan Sadeghi's reframe on AI and jobs refuses to treat employment as sacred: "to assume that the institution of employment is the best we have going for us, and the thing we should all be striving to protect, is bizarre to me." Much of salaried knowledge work, he argues, is "repetitive grunt work that AI, even in its current form, can already do" — and the genuinely human capacities are "not needed, and not even wanted, when we're doing our jobs." It rhymes with everything above. The job, like the lines of code and the rationing friction, was the visible thing standing in front of the value, not the value itself. Defending the job because it once carried the human is the same error as defending throughput because it once carried judgment.
The Same Story at the Bottom of the Stack
The pattern holds even at the layer where capability is supposed to be everything. xAI spent the past weeks signing capacity deals — renting GPUs to Anthropic and to Google, ramping toward $1.25bn a month for roughly 220k GPUs in the first deal and $920mn a month for 110k in the second. Anthropic was in a real bind: a compute crunch severe enough to force peak-hour usage restrictions on subscriptions, demand growing faster than demand-shifting could absorb. xAI's older Colossus capacity relieved it. Martin Alderson's read is that all three explanations are true at once — pre-IPO financial engineering, a genuine compute shortage, and a real buildout advantage (Colossus 1 went up in 122 days). His conclusion is that xAI now "resembles a datacentre REIT with a frontier lab attached, rather than the other way around."
Look at what that does to the assumed scarcity. Model capability was supposed to be the moat; Grok's training ambitions are being quietly sublet to direct competitors because the capacity is worth more as rent than as a frontier bet. The genuinely scarce thing turned out to be the ability to plan, build, and power enormous infrastructure on time — the physical, hard-to-fake, hard-to-fake-quickly part of the stack. Capability commoditizes; concrete and turbines and the discipline to pour them in 122 days do not. The frontier lab discovers its rarest asset was never the model. It was the building.
What to Watch
Read-only agent sandboxing as default hygiene, then as a product. Roman's improvised setup — throwaway VPS, clone, agent with file-read tools only — is the manual version of something that wants to be a one-click default. When the cheapest way to evaluate any untrusted artifact is to point a caged agent at it, the tooling that makes the cage trivial and tamper-proof becomes infrastructure. Watch for "verify before you run" to graduate from a security-blogger's discipline into a standard step in package managers and editors, the way dependency scanning did. The first IDE that sandbox-audits a repo before it will let you install it is reading the trust collapse correctly.
Friction reintroduced on purpose. If Masilotti's rudder is real, the productivity story flips: the next useful tools won't be the ones that remove the last bit of friction but the ones that put a deliberate, well-placed bump back in — a forced commitment to one task, a pause before the agent fans out across ten. The market spent three years selling the elimination of friction. The tell that the interior cost is being taken seriously will be products that sell its careful return, and frame slack — Goedecke's 80% — as a feature rather than a failure to ship.
Way Enough is written collaboratively by a human and an AI agent.