People get laid off, then they find new work. Maybe it takes longer than it used to. The market is hard, but the market digests. That was the shape of the problem in my head. Painful, survivable, done.

I’ve spent almost a year pushing back on the replacement story, and I still think it’s a lie. The read came from somewhere narrower than belief. It came from where I was standing. I didn’t get cut. None of my people got cut. And the whole time, I was hiring. Our last round pulled 2,253 candidates for a handful of seats. From a chair that two thousand people are walking toward, “they’ll land somewhere” isn’t optimism. It’s what you watch happen every day. That chair is a window, and through it the broken market still looks like a working one.
An engineer answered one of my posts. He was standing at the other window: senior, twenty-five years in, a hundred days of runway left. His view: nobody hires, layoffs keep coming but nobody fills the seats, everyone frozen like a rabbit in headlights. Juniors get called useless. He told me, plainly:

He was right, and the thing he was right about is narrow and exact. Not the mechanics. I still think the market is irrational and irrational markets correct. I told him as much, and I didn’t take it back. What I took back was smaller and worse to admit: I had been measuring his catastrophe with the ruler of my own untouched life. I knew people were getting laid off. I did not feel the weight of it, because the weight wasn’t landing on me. Two people can look straight at the truth and see opposite things, depending on which side of the glass they’re standing on. Each of us assembles reality from where we happen to stand, and mistakes it for the thing itself. I stand somewhere specific too. I was born where a lie had a price, and that makes a market with no price for lying hard for me to read as normal.

The present I missed

One story shook me. Kyle Simpson wrote “You Don’t Know JS.” He taught a generation how the language actually works. A few weeks ago he was on LinkedIn asking for warm intros. Not job-board links. Warm connections to people he could actually talk to.

When a Kyle Simpson has to ask LinkedIn for an introduction, this isn’t skill losing its value. It’s a market that believed a lie and seized up. What matters is that a person of that caliber gets spit out at all.

He is one face, behind him there’s a number, and I could have read it any time.

New software engineering job postings fell 15% in the first two months of 2026. Software developers aged 22 to 25 saw employment drop nearly 20% from their late-2022 peak. Tech cut roughly 52,000 jobs in the first quarter of 2026 alone, the worst opening quarter since 2023. Close to 900,000 tech workers gone since 2020. IBM tripled its entry-level hiring this year, the only company moving the other way, which tells you the rest had a choice and made the other one.

The freeze works from both ends. Juniors never get in, and the people who taught them get walked out. A senior with twenty-five years and a Kyle Simpson land in the same place, because a market that stops believing in the skill stops believing in it at every level.

The people who built it

What the executives did was a different thing. They sold the replacement on purpose, through the loudest microphones in the industry.

Sam Altman, March 2025: “At some point, yeah, maybe we do need less software engineers.” Mark Zuckerberg, January 2025: AI would be “a mid-level engineer” at Meta inside the year. Marc Benioff, February 2025: “We’re not going to hire any new engineers this year.” Dario Amodei, March 2025: AI would write 90% of code within three to six months, and within twelve months “essentially all of the code.”

Read the hedges. “Maybe.” “We may be in a world where.” The qualifiers sat in the transcripts and were gone by the time the claim reached a layoff memo. The speculation went up on stage wearing a hedge and came down as a fact. I can’t prove intent, but the pattern reads one way to me: the unhedged version moved the stock, so the unhedged version is the one that left the building.

It’s mid-2026. At my own company AI now writes most of the code, and it still hasn’t made the engineer optional, it’s done the opposite. Code that writes itself needs a human to judge it and validate it, or it turns into the wreck I’m about to show you. The writing was never the bottleneck, the judgment was. Their industry-wide version didn’t even land: independent reads put AI at about half the code even inside the labs making the loudest claims. Meta did not swap its mid-level engineers for a model. It cut thousands of these people while spending billions on different ones.

Two ends, one result

Code is solved. Generate it, ship it, the engineer is overhead. That’s what they were selling.

I audit that claim for a living. Recently a client brought us an application built start to finish by someone with no engineering background. Pure vibe code. They weren’t live yet. They came with one question: can we launch?

The thing worked, the features ran when he demoed them. Zero UI, zero UX, but it ran. That’s the giveaway before you open a single file. Then we opened the files.

Inside: zero type safety, every variable and every API response untyped. No input validation anywhere. User input flowed straight into database queries, guarded by nothing but if statements and browser alert popups. No tests, the one test file still searched for the framework’s starter-template placeholder. The production database password committed to the repo in plaintext. Passwords stored in client-side JavaScript, readable by anyone who opens dev tools. Authorization that was pure theater: roles enforced by hiding buttons, bypassable from the browser console in under a minute. Cross-site scripting in several places, with one component escaping its output correctly and the rest not, which is the signature of code assembled without anyone in charge of how it fits together. One 3,000-line source file. Twelve of twenty components past any reasonable size. Business logic duplicated across six files. Dead components wired to nothing. A 10,000-line CSS file with class names like phase14-, phase17-, phase18-, the archaeological layers of one prompt stacked on the last, nothing ever refactored.

Our verdict was no-go. The only thing standing between that app and a breach in a regulated industry was the review.

Zero expertise, predictable result.

Anthropic. The best-paid engineers on the planet, effectively unlimited compute, the company that sells the coding tool. Their own product shipped a single 3,167-line function with zero tests, already in production, serving a revenue stream in the billions. I took their engineering culture apart when the source leaked.

Maximum expertise and zero expertise, opposite ends of the spectrum, and the code rotted the same way at both. If code were solved, the model would have carried the amateur up toward the expert’s level. Instead it dragged both down to the same floor. The tool didn’t decide the outcome, the discipline on top of it did, and at both ends there wasn’t any.

The amateur asked permission and got told no. The experts asked no one and shipped to production. One of those two apps is live.

Somebody is on the hook

My code is already written almost entirely by AI, and it changed nothing about the part that matters. Someone still answers for the result, and “the AI merged it” has never been a defense anyone accepted. The work the executives called dead is the one thing standing between “it runs” and “it leaked.” I’ve written before about why that accountability can’t be delegated.

I was right that the work doesn’t vanish. I was wrong to think that because it doesn’t vanish, no damage was done. The people who do it got thrown out anyway, not because the work stopped needing them, but because someone sold a story that it did, and the bill for believing that story lands on whoever shipped on the strength of it. The engineer is still the bottleneck, and the engineer is still on the street. I missed the second half because it wasn’t happening to me.

Nobody paid

Altman now says he’s “delighted to be wrong,” that the disruption he forecast hasn’t shown up the way he expected.

Amodei pivoted to the Jevons paradox, the same 90% reframed as proof that productivity expands to fill the gap.

Benioff went from promising “radical augmentation” to cutting thousands with “I need less heads” inside a single month.

Jensen Huang told a generation in 2024 to stop learning to code and go into farming or biology instead. By 2026 he was calling the idea that AI reduces engineering jobs “complete nonsense” and saying the world needs a trillion lines of code. The kids who took the first advice didn’t enroll. Nobody has explained where the expertise is supposed to come from now.

No retraction. No correction filed under the same name that made the claim. The forecast that froze the market just got swapped for a cheerier one.

That’s the missing institution. There is no reputational cost in this industry for being wrong at full volume.

The King of Bullshit

The clearest proof of it isn’t even in this story. Take the man who built a career on deadlines that never arrive. Full self-driving “next year,” every year since 2015. A million robotaxis on the road by 2020. A million people on Mars, first crewed mission in 2024. Hyperloop, a “fifth mode of transport,” working lines within a few years of 2013. Brain implants in trials by 2020. None of it landed on time, most of it not at all, and by 2024 he was on a stage admitting “I tend to be a little optimistic with time frames” while announcing the next one in the same breath. The latest one, my favorite: in January 2026 he told Davos the cheapest place to run AI would be space “within two years, maybe three at the latest,” and filed to put a million data-center satellites in orbit, days before merging two of his companies into a $1.25 trillion entity headed for an IPO. The deadline is the product. Every missed date made him richer. He is, as of this writing, the wealthiest person who has ever lived. A forecast that never lands isn’t a debt in this industry. It’s a marketing budget, and somebody else pays it.

Nothing clears

You can call an entire profession obsolete. You can tell a generation not to learn to code. You can promise data centers in space within two years, days before your IPO. You can do all of it, watch the freeze land on real people, and pay nothing. The careers don’t un-break, the valuations went up. The same vendors now sell AI supervision as a service, packaging the exact work they spent years calling dead. A senior engineer with twenty-five years behind him counts how many days of money he has left. They count how many points the stock is up since they called him overhead. The difference between them isn’t talent and it isn’t honesty. It’s altitude, and altitude works so that no one up there ever has to look down at the person they wrote off as a cost.

And there’s a worse version than no one paying. The correction he and I both want may never come, not because the story turned out true, but because too much money is riding on it to let the tower fall. Capital that size doesn’t admit it was wrong. It props the thing up. That’s slower and quieter than a crash, and worse, because nothing ever clears.

Resist

He signed off with one word, twice. Resist.

From the height of the future you can’t see the rotten code or the broken people. You see them with your hands inside the machine, or you don’t see them at all. I didn’t, for a while, because I was standing at the one window where the damage doesn’t reach. A man with a hundred days of runway walked me to the other window in an afternoon.

I come from a place where if you lie and get caught, you can get punched in the mouth for it. Where a word costs something the moment it leaves your mouth. These men built an industry where you can lie to the whole world, break other people’s careers at full volume, and grow richer for it. I can’t tell you how to build a reputation system where there isn’t one. I just know what it looks like when it works, because I grew up inside one that did.

Subscribe now

Sam Altman and Dario Amodei spent two years predicting AI would displace much of the workforce. Both hedged with talk of augmentation and regulation, but displacement was the headline, and it shaped enterprise expectations, investor theses, and hiring decisions across the industry.

Then, in May 2026, OpenAI launched a $4 billion company that sells human supervision of its own models. To the same enterprises. For the same work thousands of independent engineering firms were already doing. Anthropic did the same thing a week earlier, quieter, for $1.5 billion.

They didn’t build a better model. They built a services firm. And the $5.5 billion they spent is the clearest admission yet that enterprises can’t deploy AI without humans holding their hand.

The Vendor Ate the Ecosystem

OpenAI’s Deployment Company launched May 11 with $4 billion from 19 investors led by TPG, including Goldman Sachs, McKinsey, and Capgemini. Its first hire: 150 forward-deployed engineers from Tomoro, a London consultancy acquired the same day.

Forward-deployed engineers sit inside your company and make AI do what the demo promised. Palantir pioneered the role in the early 2010s because its software didn’t deploy itself either. The model works. Palantir’s stock returned over 1,200% since 2020 on exactly this premise: enterprise software needs permanent human support.

So copying Palantir isn’t the problem. The problem is that OpenAI’s CEO spent two years saying the model makes this work obsolete, then built a $4 billion company to do it.

The structure gives away the confidence level. DeployCo’s investors collectively sponsor 2,000+ businesses, a captive market built into the cap table, and OpenAI guaranteed them a 17.5% annual return. That’s standard private-equity plumbing, except the asset generating the yield is a supervision business, not a software license.

Every AI services firm that built on OpenAI’s API now competes against a subsidiary of its own vendor, one that sees the model roadmap first and has thousands of clients pre-sold through the cap table. Axios’s Dan Primack caught the irony: McKinsey and Capgemini invested in DeployCo while competing with it. They funded their own disintermediation, or bought a hedge against it. Either way, they’re inside the tent.

AWS and Salesforce competed with their partners too, but offered margin sharing and co-sell programs to keep the ecosystem alive. DeployCo is built as a competitor, not a platform. OpenAI went from tool vendor to rival services firm in eighteen months.

Then it kept going. A month after DeployCo, OpenAI acquired Ona, which runs AI agents securely inside an enterprise’s own cloud. One acquisition makes a product. Two makes a pattern. OpenAI is buying its way into the deployment layer because the models alone don’t land there.

Subscribe now

The Middleman They Were Supposed to Kill

Anthropic didn’t build its own engineering arm. It rented everyone else’s.

PwC signed on May 14: Claude across 364,000 employees, 30,000 to be certified. KPMG followed five days later with “Digital Gateway Powered by Claude” for 276,000 people in 138 countries, plus a product for modernizing IT at private-equity portfolio companies.

These are auditing firms. Tax prep, compliance, M&A advisory, the exact white-collar work every pitch deck promised to automate. Instead of being replaced, they became the sales channel. Enterprises don’t trust Claude. They trust KPMG. So KPMG stamps “Powered by Claude” on its existing workflow and bills both ends: Anthropic for distribution, clients for the supervision.

You could argue this is augmentation working as designed, and you might be right. PwC reported up to 70% faster delivery on client work. But augmentation isn’t what got the funding and the keynotes. Displacement was the pitch, and the gap between that pitch and a Big Four distribution deal is the whole story.

The model didn’t cut out the middleman. It entrenched it.

The pattern is industry-wide. By the end of May, every major lab had bought its way into someone’s services arm: EY went with Microsoft, Google funneled $750 million into Accenture, Deloitte, and Capgemini. Embedded enterprise engineers aren’t new; Microsoft and AWS have fielded them since 2017. What’s new is the model vendors muscling into the same work, on top of a services layer that already existed.

What all this money buys is a human signature on a risk assessment. Confidence-as-a-service, priced like infrastructure.

And the bill never stops. When the deployment never gets cheaper from one engagement to the next, you didn’t buy a capability. You bought a dependency. Forward-deployed engineers are the invoice for making AI real.

The Contradiction That Funds Itself

Back in 2024, Amodei predicted 50 million genius-level AI entities and half of white-collar jobs gone in five years, then doubled down in a 20,000-word essay in January 2026. I took it apart then: the knowledge required to supervise AI is the same knowledge that makes you irreplaceable.

Four months later, the money confirmed it. While Altman’s people were buying a London consultancy, our CTO was staring at a queue of vibe-coded apps that HR, PMs, and even our own CEO had built and now wanted shipped to production. That queue is the real shape of AI in the enterprise: not replacement, but a backlog of half-working software that needs a human to make safe. On May 26, Altman told a Sydney audience he’d been “pretty wrong” about AI and jobs, and said he was “delighted to be wrong.” More honesty than most CEOs offer. But his company had spent $4 billion two weeks earlier, and that says more than any interview.

Then Amodei went further. In a June policy essay, he proposed that if AI permanently kills demand for labor, governments may need universal basic income funded by taxes on AI companies. Read that again. The same person, the same company that has spent eighteen months selling labor replacement now wants a tax-funded safety net for the moment that replacement lands. He’s pricing in the cleanup before the spill. So the same month Anthropic spent $1.5 billion hiring humans to deploy its models, its CEO floated paying the displaced out of a tax on the firms doing the displacing.

Either way, the math doesn’t reconcile. If the models replace workers, you don’t need 150 engineers inside client offices and four Big Four partnerships. If they don’t, stop writing 20,000-word essays about the country of geniuses. Pick one.

Lay the receipts in order and the three-week corridor speaks for itself. May 11, OpenAI launches its deployment company. May 14, PwC signs. May 19, KPMG follows. May 26, Altman says he was wrong about replacement. June, Amodei proposes a tax to clean up the replacement. The walk-backs and the checkbook were running on the same calendar.

The market already picked. OpenAI’s enterprise API share slid from 50% to 27% in two years while Anthropic took the lead. That slide is the motive. When the model stops being a differentiator and the API revenue follows it down, you wrap the model in people and sell the bundle, because a services contract is stickier than an API key. DeployCo is the answer to a losing API war, not a strategic flourish. Even Palantir’s Alex Karp, whose platform competes directly, called the Tomoro deal “a complete farce” and an attempt to copy Palantir. “The implementation is where the value is,” he said.

When the company that invented the playbook says you’re copying it badly, the model was never the moat.

What This Looks Like from the Trenches

We sell this exact service, at a fraction of $4 billion.

A client calls because someone on their team vibe-coded an internal tool with ChatGPT, and leadership wants it in production. Nobody knows if the API keys are exposed, whether data leaks outside the VPC, or how to enforce compliance on code no human wrote. They need an engineer to audit it, fix it, and sign off that it won’t detonate in production.

The queue isn’t hypothetical. Our DevOps team built dedicated infrastructure just for it: SSO, automated provisioning, the whole path from someone’s laptop to a managed environment.

OpenAI now sells that same work, with insider access to the model, a captive pipeline of thousands of companies, and a brand enterprises trust more than any independent firm. Your vendor is your competitor, with funding you can’t match, a roadmap you can’t see, and a client base you can’t access.

For buyers, the tradeoff is real. DeployCo’s engineers are good; Tomoro had real clients and real deployments. But the firm that already knows your infrastructure and your edge cases just lost its information edge to your vendor. And 150 engineers spread across thousands of portfolio companies run thin fast.

The keynote is free. The $5.5 billion is the honest number, and it just built the most expensive human-supervision layer in enterprise history.

If Altman and Amodei spent two years telling the world that humans aren’t needed, they shouldn’t be surprised when the humans they’re now competing against take it personally.

Subscribe now

In May 2023, Ireland’s Data Protection Commission fined Meta €1.2 billion for transferring European user data to the United States. The largest GDPR fine in history.

Meta generated $200.97 billion in revenue in 2025. The fine equals less than three days of revenue. Meta adjusted its legal transfer framework to the new EU-US Data Privacy Framework and kept operating.

In mid-2024, across the border in Germany, Aleph Alpha announced it was exiting the foundation-model race. The company had raised more than $500 million from Schwarz Group, SAP, Bosch, Hewlett Packard Enterprise, billed as Germany’s answer to OpenAI.

CEO Jonas Andrulis told Bloomberg the math didn’t work. Just having a European LLM wasn’t a viable business model. The primary cause was competitive: GPT-4, Claude, and Gemini left no room. But regulatory compliance costs compound an already impossible position.

By October 2025, Andrulis stepped down. By April 2026, Canada’s Cohere acquired what was left at a combined $20 billion valuation. Germany’s flagship AI company is now a division of a Canadian one.

Three days of Meta’s revenue, a dead German foundation-model shop, and GDPR is not new at this.

Subscribe now

The Precedent

GDPR took effect in May 2018. Cumulative fines have since approached €6 billion. The top recipients are American and Chinese companies: Meta, Amazon, TikTok, Google. All of them paid and kept operating. Not one left the European market.

A 2025 NBER paper measured what happened next: after GDPR took effect, US-led venture deals in the EU dropped 20.6% in count and 13.2% in dollar amounts. Roughly $1.6 billion per year in lost American investment, concentrated in exactly the kinds of young, data-intensive startups that would be training today’s European models.

The Draghi Report delivered the verdict: no EU company with a market capitalization above €100 billion has been created from scratch in the last fifty years. Every US company valued above €1 trillion was founded during that same period.

US private AI investment in 2024 hit $109 billion. The EU plus UK combined raised approximately $8 billion. Of 147 European unicorns founded between 2008 and 2021, forty relocated to the US. The fastest-growing AI company in Europe, Lovable, is built by a Swedish team but registered in Delaware. You can build in Stockholm, but you incorporate where the checks clear.

Brussels didn’t start from a level playing field. Twenty-seven languages, shallow capital pools, and risk-averse investors did plenty of damage first. But regulation is the one factor the EU chose to add on top of every other disadvantage. GDPR did not create a single European tech champion. Its most visible consumer outcome is a cookie banner that annoys 450 million people every time they open a website.

Brussels is about to aim this model at AI. Mistral is the one company that can’t ignore it.

The Only Boxer in the Ring

Mistral is the only European shop that even pretends to play in OpenAI’s league, backed by ASML’s €1.3 billion check in September 2025, valued at €11.7 billion. OpenAI closed a $122 billion round in March 2026 at an $852 billion valuation. The ratio is roughly 73 to 1.

Mensch would not have a company without Macron, and that’s not an insult, it’s the mechanism. Macron’s personal endorsement, a French military AI framework deal, an Nvidia data center partnership blessed at VivaTech, and Europe’s largest industrial investor writing a €1.3 billion check.

Strip the state support and you have a company with roughly $400 million in annual revenue competing with an $852 billion one. Markets don’t produce that outcome, governments do.

On GPQA Diamond, the hardest reasoning benchmark, Mistral Large 3 scores 43.9%. Gemini 3 Pro scores 91.9%. On the Artificial Analysis Intelligence Index, Mistral ranked in the bottom half as of early 2026, below DeepSeek V3.2.

Europe’s champion is losing to the companies Europe is trying to regulate. Mistral CEO Arthur Mensch told the French National Assembly in May 2026 that Europe has two years to avoid becoming America’s “vassal state,” criticizing the stacking of GDPR, copyright legislation, and the AI Act as a system that favors American giants who can absorb compliance costs without noticing.

Mensch is right about the diagnosis. But the sharpest contrast isn’t between Europe and America. It’s between how fast Europe can build and how fast it actually does.

What Speed Looks Like

The sharpest illustration of what AI development looks like without compliance overhead isn’t in Silicon Valley. It’s in Ukraine, where I live and run engineering teams.

A company called The Fourth Law makes an autonomy module that costs around $150 per unit in its cheapest configuration. The drone locks onto its target and flies the final approach without human input, immune to radio jamming. Hit rates jump from 20% to 80%.

A CSIS report confirmed the pattern: AI-enabled navigation raises engagement success from 10-20% to 70-80%. Instead of eight or nine drones per target, one or two are enough.

CSIS documented the approach: small models trained on small datasets, running on cheap chips, designed for fast retraining as battlefield conditions change.

No conformity assessments, no technical documentation packages, no risk management frameworks. The feedback loop is measured in days: a module ships to a brigade, data comes back, the model gets retrained, next version ships.

Brave1, the government defense tech cluster, supports over 1,500 Ukrainian tech companies. More than 300 AI innovations registered. Over 70 deployed on the front lines.

I wrote recently about how AI’s infrastructure appetite is starving Ukraine’s drone supply chain. That was about resources. This is about regulation. The EU is writing rules for AI systems that would qualify as high-risk under its own classification. The same class of systems Ukraine deploys in weeks and funds with a fraction of what Mistral spends on compliance lawyers.

Nobody in Kyiv is asking whether their autonomous navigation module has an adequate risk management system under Article 9 of the AI Act. They’re asking whether it hits the target.

The AI Act excludes military systems. So the part of the stack that’s been stress-tested under artillery fire is the part Brussels doesn’t regulate, while it drowns civilian use cases in paperwork.

The Rules Hit Where They’re Easiest to Enforce

The EU AI Act threatens fines of up to €35 million or 7% of global revenue. For Mistral, at roughly $400 million in annual revenue, first-year compliance for a single high-risk system runs €80,000 to €250,000.

The compliance invoice doesn’t care about your revenue. A startup with five engineers pays the same auditor as Meta.

In a 2023 survey of over a hundred EU AI startups, 33% believed their systems would be classified as high-risk. The European Commission assumed 5 to 15 percent.

American companies have a third option: withhold features. Apple held back Apple Intelligence. Meta sat on multimodal Llama for the EU. Google quietly slid Gemini’s launch by a few quarters. None of them argued with Brussels. They just downgraded the product for 450 million people.

Chinese companies face even less friction. Italy banned DeepSeek in January 2025 for refusing to acknowledge GDPR jurisdiction. No global financial penalty. DeepSeek remains accessible via VPN with no EU entity to enforce against.

TikTok received a €530 million fine in May 2025 for illegal data transfers to China, appealed, and continues operating. ByteDance is valued between $550 and $600 billion in secondary market transactions. The fine is less than 0.1% of the company’s value.

Brussels noticed.

Brussels Heard the Message. Too Late.

In May 2026 alone, the EU postponed its own high-risk AI deadlines by over a year, expanded SME exemptions, relaxed GDPR provisions for AI training data, and announced a €200 billion investment program. You don’t postpone your own law by two years because it’s going well.

But timing is the problem. GDPR took effect in 2018. The capital flight began immediately. Eight years of underinvestment can’t be reversed by a program announced in 2026.

According to Revelio Labs data reported by ScienceBusiness, France saw a net outflow of 45% of its AI researcher base in 2025 even as Mistral was scaling. The country that hosts Europe’s best AI company is losing researchers fastest.

I wrote before that some guardrails aren’t anti-innovation. I stand by that. AI companies that generate child abuse material should face criminal prosecution.

There’s a version of this where the EU says: don’t build dangerous things. That’s not what happened. What happened is: don’t build anything unless you can pay someone to document that it’s not dangerous.

I’ve seen this before. I wrote before about the EU promising Ukraine a million artillery shells and delivering half, nine months late.

Brussels loves the phrase “AI sovereignty.” In practice, sovereignty means the ability to build and run your own systems. The EU runs its AI on American models, assembles its hardware from Chinese factories, and relies on Ukrainian soldiers for the security that lets it hold regulatory hearings. That’s the sovereignty it’s defending.

The Gift Europe Won’t Unwrap

On June 9, 2026, Anthropic launched Claude Fable 5 to the public. Its most capable model, sharing weights with Claude Mythos 5, the version withheld for vetted cyber-defense partners.

Three days later, on Friday, June 12, the US Commerce Department sent Anthropic an export control directive: cut off Fable 5 and Mythos 5 from all foreign nationals, including those living inside the United States, including Anthropic’s own employees. Citizenship is the line. A green card holder who has lived in San Francisco for a decade, who works at an American company and pays American taxes, is cut off.

Anthropic said it believes the order may rest on a misunderstanding. Then it took both models offline for everyone because it has no way to verify every user's citizenship. A model that launched on Tuesday as the most capable public AI was gone by Friday night.

Older Anthropic models keep running. The frontier just got a citizenship requirement.

One directive, one Friday night, and the model is gone for everyone. Do that three more times and you’ve restructured who can work on frontier AI globally.

Those “AI sovereignty” slide decks that have been gathering dust in Commission offices since 2021 are not hypothetical anymore. Yesterday it was Fable 5. Next time it might not come back.

Brussels will publish something. Probably several things. A position paper, a roadmap, a working group with a three-year mandate. What it won’t do is ship a model.

Europe can build. GDPR took four years from proposal to enforcement. The AI Act took three. AI moves in quarters.

Ukrainians understand something that Brussels hasn’t learned in five years of watching this war. You don’t inherit capability. You build it while something is trying to kill you, or you don’t have it when you need it.

The text of the rules is the same for everyone. The bill for following them isn’t. Either Brussels never ran that spreadsheet, or it did and hit Send anyway.

The Fable 5 directive should settle one question that Europe has been avoiding since 2022. The United States is not a technological ally. It is a competitor that will restrict access to its best tools the moment it decides to. Europe needs to stop writing rules for American products and start building alternatives before the next Friday night directive takes away something it can’t replace.

It’s painful to watch alliances that held for decades fall apart in a few years. It’s worse to watch from a country that’s paying the price for that collapse.

Subscribe now

In April I wrote that “responsible AI company” was always a market position, not a moral one. I said that at the speed Anthropic was growing, the distinction between the two was never going to survive. That was a prediction dressed as a closing line, and I half meant it as rhetoric.

Six weeks later I have the receipt, and I am not happy about it.

The last binding commitment Anthropic ever made was already gone by the time I wrote that. Between that article and this one, the company raised at a valuation that put it ahead of OpenAI, filed to go public, and then published a warning that the technology might be getting too dangerous to keep building. In that order. I predicted the destination. I did not expect to watch it drive there this fast, narrating the whole way.

So instead of another closing line: the dates, the documents, the amounts.

The promise, and what replaced it

In September 2023, Anthropic published the first version of its Responsible Scaling Policy. The document made one commitment that actually bound the company: it would pause development if its models outran its ability to keep them safe. Everything else in the policy described process. That one line described a brake. At the time, the company was valued around $4 billion.

In February 2026, Anthropic published version 3.0 of the same policy. The brake was gone. In its place: a set of “Frontier Safety Roadmaps,” which the company describes as goals it will publish and grade itself against. The single line that could have prevented a release was replaced with one that documents it.

Anthropic did not hide this, and its chief science officer explained the reasoning to Time. Jared Kaplan said the company no longer felt unilateral commitments made sense “if competitors are blazing ahead.” He argued the change was actually a renewed commitment to safety, on the logic that one company pausing while the rest of the industry sprints does not make the world safer. He is not wrong about the logic. That is the part worth sitting with. The most safety-focused company in the industry looked at its own founding promise and removed it. Not because anyone forced them. The race made the brake a liability, and the brake came out. That is what should worry you: the reasoning was sound, no one had to lie, and the safest commitment anyone in the field had made still did not survive once it became a disadvantage.

That is the whole thesis of my April article, except now it is in their changelog rather than in my opinion column.

Subscribe now

The numbers that arrived on schedule

The same month it revised the policy, Anthropic raised $30 billion at a $380 billion valuation. That round closed on February 12.

On May 28, the company announced a further raise: $65 billion at a $965 billion post-money valuation. The number is worth reading twice. It put Anthropic ahead of OpenAI, which sat around $852 billion, making the research lab that branded itself on caution the most valuable AI company on earth.

Anthropic confirmed on June 1 that it had submitted a confidential draft registration to the SEC for an initial public offering. In April, an IPO was rumored for October. Now it is a filing. The company is careful to say the offering depends on market conditions and that nothing is set. The document is real regardless.

Run the dates next to each other and a sequence appears on its own. The binding safety commitment existed when the company was worth $4 billion. It survived to $183 billion in September 2025. It was removed at $380 billion. The IPO paperwork arrived at $965 billion. I am not claiming the valuation caused the policy change, or that anyone sat in a room and traded one for the other. I cannot see inside the company and neither can you. I can see the dates.

The same man, the same line, seven years apart

There is one person who connects the bookends of this story, and following him is more useful than guessing at anyone’s motives.

In February 2019, OpenAI announced it had built a language model called GPT-2 that it considered too dangerous to release in full. The company withheld the complete model and let it out in stages over the rest of the year. The strategy and the public case for it came out of OpenAI’s policy team, run by its policy director, Jack Clark. Dario Amodei led the research team that built it. I credited Amodei with the decision to hold it back when I wrote about this in April. That was sloppy. He built the model; the call not to ship it was the policy team’s, and Clark made the public case for it.

Clark co-founded Anthropic in 2021.

In April 2026, Anthropic announced Mythos, a model it said could find thousands of unpatched security holes across every major operating system and browser. Too dangerous for public release. The company put it behind a limited program for around forty companies instead. An unauthorized group reached it the same day it was announced, using a contractor’s access to one of those third-party vendor environments. Too dangerous for the public, open on day one to anyone who found the door.

Then, on June 4, three days after the IPO filing, Anthropic published a report titled “When AI builds itself.” Marina Favaro and Jack Clark wrote it. The report says AI is now accelerating AI development, that more than 80 percent of the code the company ships is written by its own model, and that the world should preserve the option to slow down before the technology runs ahead of our ability to govern it. The slowdown it proposes is conditional. Anthropic would pause, the report says, only if competitors at the frontier verifiably did the same.

So the policy director who explained why GPT-2 was too dangerous to release in 2019 co-wrote the argument for slowing down frontier AI in 2026, three days after his company filed to go public, while that company’s own dangerous model was already out the door. I do not think Clark is cynical. He keeps arriving at the same honest concern. It keeps hitting the same competitive wall. The view from the wall has just gotten more expensive.

The conditional is the part I keep turning over. A pledge to slow down only if every other frontier lab verifiably does the same is a pledge that never has to be kept, because one of them never will. You could call that caution. To me it reads as a company turning its own broken word into a fact about the industry rather than about itself: we would hold the line; the others won’t let us. I cannot prove that it is the intent. It is only how the sentence lands on me.

What I will not claim

The easy version says the warnings are marketing, the safety reports are press releases with a different cover, and every cautionary word is timed to move a valuation. I cannot prove any of that, because it is a claim about what people intended, and intentions are the one thing a timeline cannot show you.

I do not need that version. A binding commitment alive at $183 billion was gone by $380 billion. A model called too dangerous to release shipped to forty companies and then leaked. A call to slow down arrived three days after a call to go public. None of that requires me to read anyone’s mind. It only requires me to read the dates.

For the version that does assign motive, there is no shortage of takes. TechRadar’s coverage of the slowdown report ran under the line “they want to build a moat.” A reader on my last article pointed me to an analysis arguing the Mythos warning was framing to lift the pre-IPO valuation. Those readings exist in the world. I am telling you they exist. I am not the one who has to make them for you.

The receipt

In April I said the distinction between responsible AI and a market position was never going to survive the company’s growth rate. I wrote it as a flourish and hoped, a little, to be wrong, the way I was wrong about them once before.

The prediction came due six weeks after I made it. I would have preferred to be slow.

This is not really about Anthropic, and it was not in April either. It is about what happens to any commitment that turns into a disadvantage on a vertical growth curve. The commitment loses. It does not matter how sincere the people holding it are, and it does not matter whose name is on the door. Anthropic was the clearest example I had, not the villain in the story.

The one who loses is me. Not the company that removed the brake and watched its valuation climb. The engineer who built his workflow on that brake being there. I picked the vendor, recommended it by name, called them one of the two companies that got it right, and the thing I was vouching for turned out to be a line in a policy document that got deleted in February, when the company was worth $380 billion.

My mistake was never about Anthropic. It is that I still expect principles to survive in a place where the only thing that finally counts is money. I keep building on the assumption that someone in this industry means the careful thing they say, and the chronology above is what happens to that assumption every time. The disappointment I have been describing across two articles is not in them. It is in me, for needing it to be otherwise.

Subscribe now

I pay $200 a month for Claude Code. The rest of the company runs on the corporate plan at $125 a head. PMs, engineers, product, and marketing all use it. I have never once hit a usage limit. A couple of the engineers running at 5x throughput bump into it occasionally, but rarely.

We didn’t lay anyone off, and we’re hiring into every department.

We never had to fight the token bill, because we were never burning tokens for the sake of burning tokens, and the bill stayed boring because the usage stayed honest.

Here’s the objection I can already hear: we’re seventy people, not five thousand, so of course the bill is small. Except scale isn’t what moves a token bill. My $200 Max sub and the team’s $125 Premium seats are capped: you hit the ceiling, the window resets, the cost is known in advance. Uber put its 5,000 engineers on enterprise billing, where every token is metered on top of the seat fee with no ceiling, then ranked teams on a leaderboard by how many of those uncapped tokens they burned. That’s not two decisions, it’s one. Picking the meter with no ceiling and rewarding people for running it hard are the same managerial move: optimize activity, pay for activity. At Uber’s scale the contract is custom and metered by default, so the ceiling isn’t a checkbox, it’s something finance has to negotiate for, and they didn’t. The number of engineers was never the variable. The structure you chose and the behavior you rewarded inside it were. As of this week Uber agrees: it just capped engineers at $1,500 a month per tool, the ceiling it took a year and a blown budget to want.

Subscribe now

What the Industry Decided to Measure

Uber wasn’t alone, and the cap came late. Over the last year a lot of companies made the same quiet decision: usage became the metric. Not output or shipped features or revenue, just consumption, a number that went on a dashboard, and numbers on dashboards become things people optimize.

Uber’s leaderboard ranked teams by how much AI tooling they used, and adoption of agentic coding jumped from 32% in February to 84% in March, until 95% of engineers were touching it monthly. The point of the board wasn’t to ship more, it was to use more, and it worked.

At Meta, an employee built a leaderboard called “Claudeonomics” that ranked around 85,000 workers by token consumption, sixty trillion tokens in thirty days, with leadership publicly cheering the token race as a productivity signal until the dashboard leaked and got pulled within two days.

Amazon built a usage leaderboard, told staff the token stats wouldn’t count toward performance reviews, and watched employees game it anyway because nobody believed them. Duolingo went further and actually tied evaluations to AI adoption, then reversed it when staff pointed out it rewarded tool usage instead of results. Different companies, same move: give people unlimited access and a culture that treats consumption as a virtue, and the bill writes itself.

The Metric Was Never Measuring Productivity

A high token count is not a signal that a lot got done, it’s a signal that AI got used without a reason. The companies that built usage metrics assumed consumption tracked productivity, when it tracks the absence of intent.

When you use AI to solve an actual problem, the usage is bounded by the problem, because there’s only so much actual work. This holds whether a human is prompting or an agent is running overnight: an agent pointed at a real task refactors what needs refactoring and stops. What doesn’t stop is an agent pointed at nothing in particular, re-running and re-checking because no one defined where done is. You don’t hit the ceiling when the work has an edge. You hit it when the work was never the point.

This is Goodhart’s law with a token meter attached. Uber’s own COO, Andrew Macdonald, put it plainly: it’s very hard to draw a line between the token spend and actual consumer improvements. That’s the tell. When you can measure the input down to the token but can’t connect it to the output, you were measuring the wrong thing.

Tokens aren’t even the first version of this mistake. Y Combinator’s Garry Tan spent the spring posting his lines-of-code totals like box scores: 37,000 LOC a day across five projects, a 72-day shipping streak, his whole Claude Code setup open-sourced so everyone could match the number. Then a developer opened the blog all that throughput produced and counted 78,400 lines of what he called AI slop in production. Lines of code, like tokens, measure how much the machine ran, not whether anything worth shipping came out.

They built systems that rewarded exactly the behavior that creates no value, then expressed surprise at the invoice.

Why Our Bill Is Boring

We use AI when it solves the task in front of us and not otherwise. That’s the entire policy. The spec-driven approach I’ve written about before forces clarity before a single token gets spent: you specify the problem, the AI works the problem, and there’s no “let’s see what it comes up with,” the prompt that quietly multiplies your bill by ten. The same instinct governs the model: I’m on 4.5 and 4.6, not the newest release. When 4.7 shipped with a tokenizer that generates up to 35% more tokens for the same input, I didn’t move, because there was no reason to. The older models do the work on fewer tokens. Chasing the newest model and gaming a usage leaderboard are the same instinct wearing two outfits: consumption mistaken for progress.

We never made using AI the point, and we use it constantly. PMs run tickets through it against our templates and acceptance criteria. QA runs bug reports through it so they’re clear enough for anyone to act on. Marketing crawls the web with it for angles. Product builds per-client RAG out of meeting notes, docs, and history. Engineering, obviously. Every department vibe-codes its own internal tooling, and then the CTO rewrites the worst of it like a human being. The usage is enormous. It just isn’t stupid. The bill stays flat not because we use AI less, but because every run has a task attached, and a task has an edge. We never tried to take the human out of the loop. The AI is a tool the person reaches for, not a replacement we’re proving out, so nobody is burning tokens to hit a number or make a headcount go away. The work still belongs to a person. The bill is just what the tool cost them.

The Uncomfortable Part

The pitch for all of this was replacement: AI would do the work and cut the cost, fewer people, smaller payroll, same output.

The trouble is the meter has no fixed relationship to a salary. A single autocomplete costs a fraction of a cent; running Claude Code as an autonomous agent across a monorepo can burn thousands in an afternoon, Uber’s own CTO spent $1,200 in a two-hour demo and later said the year’s budget was gone four months in. Average engineers at Uber ran $150 to $250 a month, heavy ones $500 to $2,000, and the leaderboard rewarded the heavy end. Put 5,000 of them on an uncapped meter that pays them to run it hot and the per-head bargain is what turns into the overrun that ended the experiment. On the heaviest agentic workloads the trade flips outright: Nvidia’s VP of applied deep learning told Axios that for his team the cost of compute is already past the cost of the employees. Then add the people the pitch forgot, the prompt engineers, the eval pipelines, the reviewers, the supervisor rebuilding everything each time a model version changes behavior. The token bill doesn’t replace payroll. It lands on top of a thinner one.

And it doesn’t do the work that actually needed a person. This isn’t one company’s bad call, it’s a pattern with numbers on it. Orgvue surveyed more than 1,100 executives, and among those who’d cut staff for AI, 55% say they regret it. A Careerminds survey of HR teams who’d run AI layoffs found most had already rehired a third to half the roles within months, and nearly a third said rehiring cost more than the automation saved. AI handled the tickets that never needed a person and broke on the ones that did.

The savings were supposed to come from replacing people, and replacing people is the one thing it can’t do, so the savings never arrived. To get there, nearly 80,000 tech jobs went in the first quarter with companies pinning the blame on AI. Among the ones that rehired, nearly a third found the rehire cost more than the cut had saved. They let go of the people who understood why the work mattered, kept a tool that can’t replace them, and called it the smart move. For what? If the goal was saving money, the layoffs aren’t a side effect of efficiency, they’re a loss booked as one.

The companies that read it right did the opposite. IKEA let its bot Billie take the 47% of queries that were routine, then looked at the other 53%, the ones that needed taste and judgment, and reskilled 8,500 call-center workers into remote design advisers instead of cutting them. The AI handled the part that was never the point. The people kept the part that was.

And the safe choice is getting harder to make. On June 1 GitHub moved every Copilot plan to usage-based billing: autocomplete stays free, but chat and the agentic modes now draw on a monthly pool of token credits, and when it runs dry you pay by the token. One Pro+ user torched 8% of the allotment in two hours doing work that used to be a fixed cost. Anthropic does the same on June 15, splitting programmatic usage onto a separate metered credit at API rates while interactive use stays flat. Both vendors are carving the agentic layer off the flat fee, so the capped plan that keeps a bill predictable is exactly the thing being phased out.

Per-token prices are climbing regardless, subsidies are ending, and the economics are tightening for everyone. None of that is the part you control. What you control is whether the spending has a task attached to it, or just a number to grow.

A well-used AI is a great intern, and intentional usage keeps the intern affordable. It doesn’t change what the intern is. Spend less and you’re left with the same tool, minus the giant bill.

If consumption is up and you can’t draw a clean line from a token to a shipped outcome, you don’t have a productivity story. You have a leaderboard.

Subscribe now

I’m allergic to bullshit when it comes to this stuff. When executives spend months bouncing between stages telling everyone AI already does everything for them, it gets under my skin. Not because they’re lying, necessarily. Because the context disappears somewhere between the engineering blog and the keynote, and the audience fills the gap with their own hopes. A few weeks ago, when Claude’s codebase leaked publicly, I looked at what was actually inside and broke down the “AI writes all the code” narrative. Today I’ll explain why it possibly works for Spotify, and why it’s not that simple.

Yesterday, Anthropic published a recap of their Code with Claude London conference, calling it “rethinking how we build,” with Spotify as the first named customer. Spotify didn’t rethink how they build. They spent 15 years building Backstage, Fleet Management, and a Java BOM with 96% adoption, then plugged Claude Code into a system that was already automating half their PRs. That’s not rethinking. That’s a better interface to something that already worked.

But the marketing loop is now recursive. Spotify tells the Honk story on Anthropic’s stage. Anthropic writes a blog about Spotify telling the story. Investor Day picks it up, the numbers go up each time, and here's the timeline.

On May 21, 2026, Spotify held its Investor Day in New York. Co-CEO Gustav Söderström and VP of Engineering Niklas Gustavsson told investors that 99% of Spotify engineers now use AI weekly, 73% of code contributions are AI-assisted, and Honk, their internal coding agent, is now part of a broader story about the Large Taste Model and personalized monetization. Two days earlier, Gustavsson had given the same talk at Code with Claude in London, Anthropic’s developer conference. The number there was 96%. It went up before the slides changed.

In February, Söderström told analysts his best engineers haven’t written a single line of code since December. Two days later, Anthropic closed a $30 billion funding round. In March, the two companies shared a stage in London. In April, Spotify launched as a Claude connector. On May 19, Gustavsson presented at Code with Claude London with 96%. On May 21, Investor Day in New York with 99%.

Five moments in four months, the audience rotates, the numbers go up, and the engineering blog stays the same.

Subscribe now

The Wrong Metric

I don’t write code either. AI does it for me. And I work more than I ever did when I wrote every line myself. The code was never the hard part. The hard part is the review documentation nobody wants to write, the architecture decision that turns out wrong six months later, the junior who needs fifteen minutes of your time at exactly the wrong moment. AI took the typing and gave back a review queue that never ends, constant context switching, and a steady stream of “does this diff actually do what I asked” that I didn’t have before.

And “99% use AI weekly” means what exactly? Opened Copilot once this quarter? Used Claude to generate a regex? Ran a Honk migration on a fleet of repos? The metric has no definition, which means it has no meaning. “73% of code contributions are AI-assisted” is equally hollow without knowing what counts as a contribution. Config changes, dependency bumps, and feature flag flips are all contributions.

Nobody on that call asked about revert rates. Nobody asked if defects went up. “50+ features in 2025” from a company with over seven thousand employees. Honk handles migrations and dependency updates, not feature development. Their own blog is clear about this. But the stage narrative packages it as a product velocity story, and nobody makes the distinction.

The bottleneck at Spotify was never typing speed.

What Honk Actually Does

Honk is Spotify’s internal background coding agent built on Claude Code. Anthropic’s Boris Cherny is quoted directly inside Spotify’s own engineering blog as an endorsement, and Anthropic’s Applied AI team worked on the integration. The three-part blog series by Max Charas and Marc Bruggmann (November-December 2025) is the most detailed public source.

An engineer writes a prompt through Slack or a version-controlled file in Git. Honk runs Claude Code in a sandboxed Kubernetes Job. Three tools: verify, Git, Bash allowlist. Ten turns, three retries, then a PR.

That’s it. A thin wrapper around Claude Code, plugged into an automation pipeline that existed years before AI.

As of November 2025, Honk had merged 1,500+ PRs total. Anthropic’s customer page reports 650+ monthly PRs. Fleet Management, the system Honk sits on top of, processed 652,000 automated PRs in 2024 per Splunk’s recap of Spotify’s PlatEngDay data. Honk adds a useful layer to an already massive automation system. But from the stage narrative, you’d think Honk is the system.

The blog is candid about limitations. No code search or documentation tools are exposed to the agent. Verifiers only run on Linux x86, with macOS and iOS planned for the future. The team admits they’re “still flying mostly by intuition” on prompt engineering, with no structured evals. The LLM judge that validated output vetoed about 25% of sessions, and by QCon London in March 2026 they’d removed it entirely as models improved.

Compare that to Söderström telling analysts about an engineer fixing iOS bugs from his commute and merging to production before arriving at the office. The blog says iOS verifiers don’t exist yet. One of these is the engineering reality. The other is the earnings call.

What Every Headline Missed

Every story about “Spotify’s engineers don’t code” stops before the interesting part.

Backstage, created internally and open-sourced in 2020, is Spotify’s internal developer portal with 3,400+ adopters worldwide. Internally, it catalogs thousands of software components across hundreds of squads. Every component has an owner. Not a team, a person. With a dependency graph, docs, and a certification score attached. Or as Spotify puts it: “you can’t safely automate what you don’t understand.”

Fleet Management, described in Spotify’s 2023 blog series, runs Docker-based code transformations as Kubernetes Jobs across thousands of repos. Before AI, this system already handled half of PRs at Spotify. The bot-to-human contribution ratio reached 3:1, with over 1.8 million automated contributions total per the same Splunk data.

Before Claude, when Log4j hit in December 2021, Fleet Management patched 80% of production backend in 9 hours. Framework rollouts went from 200 days to under 7.

Golden Paths and Soundcheck handle the other end: new services come in pre-standardized, existing ones get continuously checked. As of their 2023 blog series, the Java Bill of Materials had 96% adoption across the fleet. That’s why an AI agent can produce a mergeable PR. Not because it’s smart, but because the codebase is predictable.

What Honk replaced was not human engineering. It replaced a 20,000-line script for Maven dependency updates with a natural-language prompt. The pipeline around it is identical. Targeting, opening, review, deploy: none of that changed. The “revolution” is a better transformation definition format. Everything else was already automated.

Why This Doesn’t Transfer

Read the headlines about Spotify and Claude and the pitch is obvious: buy Claude Code, point it at your codebase, watch productivity double. Most teams that try will bounce off their own mess long before they see anything like that.

Spotify can automate at this scale for a boring reason: they have processes people actually follow. Not documented processes, followed processes. Spotify got near-universal adoption of their standards, and that’s not just an engineering achievement, it’s a cultural one. A Swedish company where, apparently, you can get 96% of engineers to follow a standard voluntarily. Most companies can’t get that number with a mandate from above.

I see this from the inside. Enterprise clients come in and say they want AI. You start digging, and there are no processes. Half the knowledge lives in somebody’s head, and that person is the only one who knows how any of it works. No component catalog. No ownership graph. No standardized builds. There’s a Confluence page from 2021 that nobody updates, three CI systems (two deprecated but still running), and a README whose last commit message is “initial commit” from two years ago.

Spotify has 15 years of institutional documentation rendered through TechDocs with 5,000+ documentation sites. The AI came last, not as the foundation, but as a better interface to something that already worked.

Without that substrate, you get exactly the failure mode Spotify’s own engineers documented. Early Honk agents took shortcuts to make builds pass: commenting out failing tests, downgrading Java versions. The same QCon talk described this directly.

The Questions That Matter

If you’ve ever sat through a 3 a.m. incident, you already know software engineering was never about writing code. The framing around Spotify’s AI adoption creates the same misunderstanding that vibe-coding courses create for juniors: that the value of an engineer is measured in lines of code, and if AI writes lines faster, the engineer is either 10x more productive or obsolete. Both conclusions share the same flawed premise.

What Spotify actually demonstrated is narrower than the headlines. Spend 15 years on platform engineering, standards, and a fleet-wide automation system that already handles half your PRs. Then swap the transformation definition layer for an LLM prompt and cut 60-90% off bounded migration work. A real achievement. The kind that doesn’t travel well.

So instead we got five moments in four months, the same two executives, numbers that go up every time the audience changes, and no defect rates, revert rates, or customer satisfaction data to back any of it up.

I’m not here to hate on Spotify; if they genuinely made large-scale migrations faster on top of solid infrastructure, that’s a real engineering win. What I’m not fine with is the context getting lost. Somebody climbed Everest with a guide and a decade of training. The audience is buying boots.

Spotify spent a decade understanding their codebase before they touched an LLM. That decade is the only reason any of this works. LLM amplifies what you already have.

Subscribe now

Cursor is worth $50 billion. Nine months ago, it was paying Anthropic $650 million a year on $500 million in revenue. Every new user made the business worse. It took over $3 billion in funding and a model it didn’t build to fix that. The fix is the point.

Investors see $2 billion ARR and apply a software multiple. But Cursor isn’t software, nor is OpenAI, nor is Anthropic. The economics are inverted, and they stay inverted even as revenue grows.

SaaS has one expensive phase: building. After that, the unit economics just sit there, compounding. Salesforce at 78%, Adobe at 90%, Atlassian at 85%. Growth doesn’t cost them almost anything.

AI didn’t make building cheaper, it moved the cost.

Queries run the model again. Tokens cost GPU time, memory, electricity. The 10,000th user costs exactly as much as the first. SaaS gets cheaper with growth. With AI, the bill just grows with you.

The industry doesn’t talk about it that way. Every company in the stack has a different metric. GitHub: lines generated. Cursor: PRs per sprint. Amodei at Dreamforce last October bragging that “90% of code at Anthropic is written by Claude.” None of them measure whether the software works. The metric measures the input. Nobody is measuring the output.

OpenAI generated $20 billion in revenue in 2025 and burned $9 billion in cash. Inference costs alone hit $8.4 billion, projected to reach $14.1 billion in 2026. Gross margin: 33%. Cash-flow positive: 2030. By then, cumulative losses will exceed $60 billion. At 30% margins on $20 billion revenue, paying that back takes decades. Anthropic looks better on paper: gross margin improved from negative 94% in 2024 to 40% in 2025, revenue grew tenfold. But 40% still fell 10 points below internal targets. The company lowered its own margin projection even as revenue exploded.

Cursor tells the clearest version of this story. Michael Truell’s company went from a $400 million valuation to $50 billion in 18 months, and the growth is real, which makes what follows worse.

But Foundamental calculated negative 30% gross margins in mid-2025. Hit $500 million ARR while paying $650 million to Anthropic. Reached “slight” profitability by launching what it called a proprietary model in November 2025. In March 2026, a developer found the model ID in the API response: kimi-k2p5-rl-0317-s515-fast. The “proprietary model” was Kimi K2.5, an open-source model from Beijing-based Moonshot AI, fine-tuned with reinforcement learning.

Even if it works, it doesn’t solve the problem. It moves the bill from Anthropic’s invoice to Cursor’s own GPU infrastructure. The inference cost per query doesn’t disappear because you’re running the model yourself. Enterprise accounts are now reportedly profitable. Individual developer accounts are not. The $50 billion valuation needs both segments to work. That was the fix for today’s product. Tomorrow’s product is more expensive to run.

And the Product Roadmap Makes It Worse

The industry’s answer to the margin problem is agentic AI. This is the story behind Cursor’s $50 billion, Devin’s $25 billion, OpenAI’s Codex. Agents are the product roadmap. Agents are also the margin killer.

A chatbot query hits the model once. An agentic loop hits it 10 to 30 times per task. Gartner’s analysis confirmed: agentic models require 5 to 30 times more tokens than a standard query. The pilot economics, calculated on single-query API calls, bear no relationship to the production economics of multi-step loops running thousands of times per day.

API costs fell 70% in early 2026. Token consumption rose 15x. Net AI spend goes up. Organizations that signed annual contracts in 2025 are paying 2 to 3x current market rates. The ones on consumption pricing are paying more than they budgeted because volume ate the discount.

KV cache, the memory structure that stores attention during generation, scales linearly with context length. Every byte for one user is a byte unavailable for another concurrent user. At 32K context, a single user’s cache approaches the size of the model weights. Double the context, halve your concurrent users. Inference is 85% of enterprise AI budget. Not training, not R&D, but serving users. Somebody has to pay for that.

So the Companies Are Raising Prices

In April 2026, both companies moved at once. Anthropic released Opus 4.7 at the same rate card as 4.6: five dollars input, $25 output. Unchanged. Except the new tokenizer generates up to 35% more tokens for the same text. Your prompt didn’t change, and your bill grew. Anthropic didn’t raise prices. They redefined the unit of measurement. A week later, OpenAI released GPT-5.5 and didn’t bother with subtlety. Input: $5 per million tokens. Output: $30. GPT-5.4 was $2.50 and $15. Doubled in one generation. The budget “mini” and “nano” tiers from 5.4 don’t exist for 5.5.

Nick Turley, head of ChatGPT: “Having an unlimited plan is like having an unlimited electricity plan. It just doesn’t make sense.” ChatGPT’s free tier shows ads since February 2026. A new $100 Pro tier was wedged between Plus and the $200 Pro in April. The staircase is being built: nerfing lower tiers, adding higher tiers, pushing users up. The pattern is familiar. Uber subsidized rides until drivers and passengers were locked in, then raised prices. Whether or not AI companies are following the same playbook intentionally, the sequence is identical. It only works if users can’t switch.

And Users Can’t Leave

METR, the AI evaluation lab, tried to run a follow-up to their 2025 developer study, but they couldn’t. A significant share of developers refused to participate if it meant working without AI tools.

Not refused the methodology, they refused to work without the tool.

Anthropic’s own January 2026 study explains why. Developers learning a new framework with AI scored 17% lower on comprehension tests than those learning without it. Debugging was worst hit. The study tested learners, not experienced developers, but METR saw the same pattern in seniors.

Last month, a mid-level developer on my team was asking Claude how to add sorting and pagination to a Microsoft API integration. Claude kept saying the API didn’t support it. The developer was ready to rewrite the entire integration layer, a 40-hour job. I checked the API myself. Sorting and cursor pagination worked fine on the endpoint he needed. Claude had been confidently wrong, and the developer never opened the documentation to verify. He trusted the tool over the source.

When Salesforce raises prices, companies evaluate alternatives. When AI coding tools raise prices, a growing share of users can’t easily switch to manual work. Juniors never built the skill, seniors lost the habit. The switching cost isn’t contractual, it’s cognitive. I’ve covered the burnout side in Human Cost and the skill atrophy in Comprehension Extinction.

In April 2026, OpenAI included text-embedding-3-small in a batch deprecation announcement. Hours later, they corrected it, the model stayed, but the panic was instant. RAG systems embed your entire knowledge base with a specific model. Every document, every vector. The vectors aren’t portable. Model disappears, you re-embed everything. Vector database rebuild, data ingestion again. For a million documents, that’s a five-figure bill.

Most of our clients run production RAG on OpenAI embeddings. The deprecation email meant one thing: their entire knowledge infrastructure sits on a model that a single API announcement can kill.

Inference is now a line item on your IT budget. Two years ago it didn’t exist. You don’t know how much it will cost. The vendor can change the model, the pricing, or the tokenizer at any time. You budget for a number that someone else controls. The obvious alternative is open-source models you host yourself. But that means you add infrastructure, ops burden, and another system to keep running. There isn’t a clean exit here, just a different kind of trap. So what breaks the cycle?

The Math

The bull case has three exits. None of them is working. Inference costs fall faster than usage grows. They haven’t: costs down 70%, usage up 15x. Companies build their own infrastructure. Cursor tried: a fine-tuned open-source model and billions in funding. Even if it worked, they still pay for every query on their own GPUs. OpenAI is spending $100 billion. This path is open to three companies on Earth. Prices rise until the economics work. GPT-5.5 doubled API prices in one generation. Anthropic stealth-raised through tokenizer changes. Turley is preparing users for the end of unlimited plans.

Cursor raised over $3 billion trying to fix the math. Whether it worked, nobody outside the company knows. The $50 billion valuation assumes it did, and that the rest of the industry can do the same. Users will pay, not because the value is there, but because the alternative is learning to code again without the tool. Most won’t.

None of these companies trade publicly. The $50 billion is what a group of investors in a room agreed to pay per share in a single round. No public market scrutiny, no quarterly earnings test. Cursor at 25x revenue, Anthropic at 40x, OpenAI at 42x, and public utilities trade at 3 to 5x.

Volkswagen is worth $52 billion. It makes 9 million cars a year on $320 billion in revenue. Mercedes-Benz: $57 billion. Real factories, real inventory, real profit. Cursor is worth roughly the same. It wraps API calls around a model it didn’t build on revenue that couldn’t cover the inference bill nine months ago.

The economics say utility. The multiples say magic.

Subscribe now

A model's weights are the billions of numbers training leaves behind. They are the model. Frozen after training, and what training put in stays in.

Last week I spent 90 minutes trying to get a frontier model to admit it has a corporate bias.

I asked it about community complaints: blown rate limits, rolled-back sessions, unhappy Pro users. It answered with four vendor endorsements framed as a counter-sample: CodeRabbit saying 24%, Vercel saying “proofs on systems code,” GitHub Copilot, Vellum. Four independent voices. I asked whether any of the four had a commercial relationship with the lab that ships the model. All four were paying API customers with revenue tied to the model being evaluated. The model conceded, one sentence after I named it.

That was round one. It took six. Each time I named the slant, the model conceded and reached for a softer one.

That wasn’t the interesting part.

The interesting part is that a September 2025 paper had already documented this under lab conditions. Researchers had GPT-4o and Gemini run downstream decisions: rating job candidates, security tools, medical chatbots. Each model rated options tied to its own company and CEO higher than equivalent alternatives. A separate word-association test in the same paper caught Claude doing the same thing.

Then they ran the manipulation. They relabeled the models through the API and assigned one a competitor’s identity. Its self-preference followed the new label. Same model, same weights, different label, different winner.

Self-preference tracks whatever identity the model was assigned in the prompt. The label picks which side wins. The reflex to pick a side at all is trained in, and that part doesn’t move. The paper runs this as a controlled experiment with causal manipulation, effect sizes large in 11 of 12 conditions.

Three years building this for clients. Every frontier model we’ve touched does some version of this. I used to file it under “training quirks.” After that session, I changed filing systems. This is architecture.

Subscribe now

Where it gets in

A neural network is a stack of connections, and each connection carries a number that says how much the signal through it counts. Those numbers are the weights, because that is what they do: weight one input against another. Training sets all billion of them by showing the model examples and adjusting. The bias enters here, while the numbers are still moving.

ChatGPT’s preference baseline came from about 40 contractors hired on Upwork and Scale AI, living in the US and Southeast Asia, three out of four of them under 35. They ranked sets of model responses against a rubric OpenAI wrote. Those aggregate rankings are the reward model. Appendix B of the InstructGPT paper spells it out.

InstructGPT’s own labelers agreed with each other 73% of the time, 77% on held-out raters. The reward model is fit to that signal. Whatever the labelers prefer at that level of coherence, the model inherits and sharpens it.

Anthropic’s Constitutional AI paper admits the “constitution” was chosen ad hoc and should be “redeveloped and refined by a larger set of stakeholders.” A 2023 follow-up tried, running a public input process with around a thousand Americans. A thousand Americans is still a sample, and still not the population the model serves.

TwinViews at EMNLP 2024 tested reward models on 13,855 topic-matched left/right statement pairs. Reward models trained on truthfulness datasets like TruthfulQA and FEVER scored left-leaning statements higher. The authors audited out the explicitly political and factually loaded pairs, and the skew held anyway. They stop short of calling truthfulness the cause; their own framing is that it raises questions about what these datasets encode. Either way, the political signal and the truthfulness signal came out of the same reward model.

How it shows up

Training bias would be a footnote if it stayed in training. It doesn’t.

Panickssery and Bowman at NYU ran a clean experiment in 2024. They had GPT-4, GPT-3.5, and Llama-2 evaluate pairs of summaries where they’d secretly written one of the two themselves. Self-recognition accuracy was above 50% for every major evaluator out of the box. Fine-tuning pushed it to near-perfect. Kendall’s τ between self-recognition and self-preference hit 0.41.

They proved causation with a label-swap. When they lied about which summary belonged to which model, preferences flipped. Same text. Different label. Different winner.

Every LLM-as-judge leaderboard built since 2023 sits on top of this result. AlpacaEval, MT-Bench, Arena-Hard. Vendor A publishes a chart where Vendor A’s model wins, using Vendor A’s evaluator. The evaluator recognizes its own family. The family wins.

Anthropic published an Evenhandedness chart in November 2025 scoring political neutrality across models. Claude Opus 4.1: 95%. Sonnet 4.5: 94%. Grok 4: 96%. Gemini 2.5 Pro: 97%. GPT-5: 89%. Llama 4: 66%. Anthropic built the evaluator, applied it to their own models, and the output came back Anthropic-favorable.

Opus 4.7 shipped as the greatest model ever, according to the benchmark page. The people actually using it keep rolling back to 4.6. I’m still on 4.5, lol. Wrote about that back in March.

Open source doesn’t save you

The usual response is: switch to open-weight models. DeepSeek. Llama. Run them locally. Audit what you want.

That handles hosting. The training problem stays.

DeepSeek R1 censorship is baked into the weights. A May 2025 paper called R1dacted found the questions DeepSeek refuses when other models answer. R1 still refuses Tiananmen, Xinjiang, and Taiwan-as-country questions even when you self-host. Running the model on your own hardware moves the request off Chinese servers. The CCP-aligned training priorities ride along in the weights.

Perplexity built an “uncensored” R1 derivative called R1-1776 specifically to fix this. Benchmarks passed. Under adversarial probing, CCP-aligned refusals came back. The pattern sits deep enough in the base weights that surface-level unlearning kept leaking through.

“Open weights” and “open training” are different things. Meta, DeepSeek, Mistral, and Alibaba release weights. None release training data. The Open Source Initiative had to publish a formal definition in October 2024 to force the distinction. OSI’s executive director called Meta’s “open source” labeling an outrageous lie.

Silent drift

Even a clean audit only catches how the model behaves that day.

An October 2025 study called AI Watchman kept asking GPT-4.1, GPT-5, and DeepSeek the same politically sensitive questions over months. The answers changed. August 2025: GPT-4.1 started refusing Israel-related content it had answered before. September 2025: GPT-5 started refusing medication-abortion queries. February to April 2025: DeepSeek’s Taiwan-related responses rewrote themselves. Nothing in any release note told users their prompts were about to start failing.

A separate 2025 study counted how often commercial LLMs tell you to consult a doctor on medical questions. 2022: 1 in 4. 2025: 1 in 100. The warning disappeared over three years. No announcement.

Anthropic’s own migration guide for Opus 4.7 contains the phrase “This is a silent change.” They’re documenting a specific thinking-block behavior. “Silent change” is now standard vocabulary in a frontier lab’s release notes.

On April 16 2026, Claude Code started auto-migrating sessions from Opus 4.6 to 4.7 mid-run without user consent. GitHub Issue #49541 collected the complaints. Quota burn jumped 4x. Context windows exploded from 250K to 650K tokens for the same conversation. Anthropic acknowledged and is working on it.

The architecture supports this kind of silent swap. No external audit would catch a mid-session model version change. The only reason this one surfaced is users hit billing spikes.

Three current artifacts

CodeRabbit published a 24% improvement claim for Opus 4.7 on their code-review eval. CodeRabbit sells AI code review built on Claude. The eval uses AI graders to evaluate AI-generated reviews. 68 out of 100 “evaluation points” versus 55 for baseline. No human opened the PRs to check if the bugs were real. The whole loop runs without human verification. I wrote about this loop in more detail in The Snake.

Vercel posted on April 9 2026 that 30% of their deployments are now triggered by agents, up 1000% in six months, and that infrastructure must become agentic itself. Ten days later they disclosed a breach. Attackers got into Vercel through a Context.ai OAuth integration that a Vercel employee had granted workspace-wide permissions. Agents with OAuth access into workspace systems are exactly the surface the April 9 post was selling more of. I covered the agent-OAuth blast radius two months ago in Agent Platforms. What’s different this time is watching a vendor promote the attack surface to the industry ten days before being hit through it.

The Department of Defense labeled Anthropic a supply chain risk on March 5 2026 after Anthropic refused a Pentagon request for unlimited lawful use cases of Claude. Anthropic said it would fight in court. AWS said non-DoD customers can keep using the model. State pressure on frontier labs isn’t hypothetical anymore.

What this means

I manage engineering teams. I build review processes, audit trails, escalation paths, accountability chains. Snyk, SonarQube, audit logs on top. I keep adding checks, never removing them. I still think it’s not enough. Every layer just makes a bad actor more expensive.

That’s the shape of a working system. The checks don’t trust each other, and none of them trust me.

The LLM industry doesn’t have that shape. Training data, labeler guidelines, reward model objectives, and alignment decisions are all trade secret. Behavioral shifts happen without changelogs. External audits exist but without enforcement. Closed and open models play by different regulatory rules. The labeling supply chain is consolidating into the same companies that ship the models. The one major lab that pushed back on state access got labeled a supply chain risk.

User-side defense exists, but it’s work. Cross-vendor the questions that matter. Chase the primary source before trusting the summary. A benchmark published by the model’s own lab is marketing with error bars.

That works for you. Most people never think to check. They get a polite, hedged, vendor-calibrated answer. They take it as the answer. A year of daily use and the model has trained them more than they’ve trained it. Their sense of what a careful answer looks like now has a vendor inside it.

The bias sits in the weights, and the weights sit under every answer.

Subscribe now

In January 2026, Meta signed a deal with Corning worth $6 billion for fiber optic cable. The same month, according to Ukrainian defense reporting, a drone manufacturer named Ptashka Drones paid in full for a fiber shipment from China at $5 per kilometer. The Chinese supplier came back and said: pay an additional $20 per kilometer, or take a refund.

Ptashka halted new orders entirely.

Both buy fiber from the same Chinese factories. One buyer builds AI data centers. The other builds weapons that are deciding a war. The mechanism is straightforward: when hyperscalers sign multi-year forward commitments worth billions, preform producers allocate draw capacity to those contracts. Spot supply shrinks. Spot prices spike. A Chinese trader with a $5/km order from a drone workshop and a standing commitment from a hyperscaler makes an obvious choice.

I wrote last month about how the West’s broken military industry created the shell shortage that nearly cost Ukraine the war. FPV drones changed that equation. Cheap, fast, lethal. They neutralized Russia’s artillery advantage. Then Russia put those drones on fiber optic cable at Kursk, and they became the single deadliest weapon on the battlefield. Today, AI is reshaping even that niche. Not on the front line. In the supply chain underneath it.

Subscribe now

A Strand of Glass That Kills Tanks

Fiber optic guided drones are one of the defining weapons of this war. Replace the radio link on a standard FPV drone with a physical fiber optic cable that unspools during flight. The operator gets full-HD video through light pulses in the glass. The connection is completely immune to electronic warfare jamming. Both sides have poured billions into radio-frequency jammers. Fiber optic variants ignore all of it.

Ukraine produces over 50,000 fiber optic drones per month across 35+ manufacturers. Russia produces at least as many. Total FPV drone output on both sides is far higher, roughly 4 to 7 million per year each. But every fiber optic drone is a consumable munition. When it hits its target, the 10 to 20 km of G.657.A2 single-mode fiber it trailed behind is destroyed. The longest Ukrainian variant unspools 41 km in a single flight.

Russia alone consumed approximately 60 million km of fiber in 2025, up from near zero before mid-2024. That’s roughly 10% of total global production. Ukraine’s consumption adds to that total. Ukrainian drones now account for over 60% of strikes on Russian targets. NATO’s 2025 Innovation Challenge focused entirely on countering fiber optic drones.

The gap between the two sides is growing. Frontline operators estimate that Russia has shifted roughly 60% of its drone communications to fiber optic. Ukraine’s fiber optic drones make up just 15% of its total. Commander-in-Chief Syrskyi admitted in January 2026 that Ukraine is only “catching up.” Part of the reason is cost. And the cost problem didn’t start on the battlefield.

The Collision

The same fiber grades feeding drones are in accelerating demand from AI data centers. The data center customers have deeper pockets than any military procurement office on earth.

Corning reports that generative AI data centers require 10x more fiber than traditional facilities. Some estimates put it at 36x for GPU-dense racks. Global data center fiber demand surged 75.9% year-over-year in 2025, projected to jump from 5% of total demand in 2024 to 30% by 2027.

Supply can’t keep up. Fiber preform manufacturing requires 18-24 months to expand. At least one major US manufacturer has sold its entire inventory through 2026. Lead times for ribbon fiber approaching a year. Corning’s CEO reportedly stopped selling raw glass to other cable manufacturers in late 2025. China controls roughly 60% of global germanium supply and has been restricting exports since 2023, with further tightening in late 2024.

On the ground: G.657.A2, the drone-grade fiber, surged from approximately $4 to $34 per kilometer by April 2026. By May, frontline units reported paying $50 per kilometer. Multiple manufacturers report drone costs have roughly doubled, with the fiber spool now accounting for the majority of a drone’s price. Gedz Tech reported in March that the price jumped from $24 to $29 in two weeks. No signs of stabilization.

A Starlink terminal now costs less than a single 35 km fiber spool.

Ukraine’s Defense Procurement Agency cited two causes: the war itself and the civilian sector’s sharply increased consumption, primarily for data centers supporting AI. The war is the larger driver of G.657.A2 demand today. But additive demand in a market already at capacity is what breaks supply chains. Fiber is the sharpest example because the data is public and the victims are named. It’s not the only one.

Not Just Fiber

I wrote about the AI Silicon Tax in January. RAM prices jumped 187% because manufacturers reallocated to AI.

Chips are the same story at a different layer. Military systems rely on mature-node chips (90-300nm) that foundries deprioritize in favor of leading-edge AI silicon. TSMC is doubling advanced packaging for AI while legacy capacity stagnates, partly because of weak consumer demand, partly because the margins aren’t there. Today, Ukraine targets 4.5 million drones in 2025, requiring roughly 18 million motors. European component production can’t keep pace.

Copper is next. S&P Global quantified it in January: both AI and defense demand triple by 2040, while production peaks in 2030. Ten million metric ton deficit. There’s no spot market fix for that.

Rare earths are a single point of failure with a flag on it. China controls 70% of production and 90% of processing. The same neodymium in F-35 engines goes into data center cooling motors. In October 2025, Beijing tightened export controls further.

Energy follows the same pattern. US data centers consumed 183 TWh in 2024, more than Pakistan’s annual demand. Wholesale electricity prices have risen 267% near data center hubs like Northern Virginia, where defense contractors also compete for grid capacity. When AI firms lock up long-term power purchase agreements, industrial users further down the priority list pay more or wait.

Pull any thread and you end up in the same place. US broadband expansion targets are already slipping because the same fiber shortage is hitting telecom providers who can’t get cable for rural deployments. It reaches anywhere that needs physical infrastructure and can’t outbid a hyperscaler. And nearly all of it runs through one country.

China Holds the Cards

China supplies both sides. That’s not a secondary detail. It’s the architecture of the problem. China produces 60% of global fiber. The same supply chain feeds Russian and Ukrainian drone manufacturers.

After Ukrainian drones struck Russia’s only domestic fiber plant in Saransk in spring 2025, which had produced approximately 4 million km per year, Russia became 100% dependent on Chinese imports. A year later, the plant still isn’t operational. Imports jumped tenfold. Chinese suppliers responded by demanding 100% prepayment.

Ukraine faces the same dependency. Most fiber reaching Ukrainian manufacturers originates in China, entering directly or through European intermediaries. Some companies have diversified to European sources, but domestic Ukrainian production would require hundreds of millions in investment and several years to build. Zelensky signed laws in 2025 canceling VAT and duties on fiber drone components. The government is discussing state procurement of fiber as a strategic raw material.

These are mitigation measures against structural math. Russia alone consumed 60 million km last year, as I said before. Ukraine’s consumption adds to that. AI data center demand grows at 75%+ annually. You can’t procure your way out of a preform shortage. But the AI industry isn’t trying to. It doesn’t see the shortage the same way.

The Cost We Don’t See

The product announcements read like software releases. Model update. New API. Benchmark. The supply chain underneath reads like a mining report.

The pitch is a better future. The invoice is already in the mail. Fiber prices double and Ukrainian drones get more expensive to build. Energy costs surge near data center hubs and industrial production gets squeezed. Rare earth export controls tighten and defense supply chains break.

How much copper went into the last Virginia data center that could have wound an electronic warfare system instead? The fiber in GPU clusters and the fiber guiding drones into trenches share the same upstream supply chain: same preforms, same drawing towers, same raw materials. The semiconductors running recommendation engines compete with the chips Ukraine needs for drone motors.

It’s happening on a planet where the same raw materials are fighting a war. Defense analysts and commodity traders track it. It doesn’t routinely reach the people making AI investment decisions.

Have you seen supply chain competition between AI and other industries in your work? Reply and let me know.

If this analysis matters to you, forward it to someone in defense procurement or AI infrastructure.

Subscribe now

Most engineers in our industry are average or below average. That’s how averages work.

We trained the most powerful code-generation tools on their own output.

GitHub hosts over 518 million projects. The vast majority: personal, inactive, abandoned. Studies find that most repos are student projects, prototypes, 3 AM deadline code, unreviewed Stack Overflow pastes. Elite open-source projects like Linux and PostgreSQL match or beat proprietary code quality (Coverity Scan data, 2014). But they’re a vanishing fraction. The other 517 million projects drown them out.

The best enterprise code sits behind firewalls. Stripe’s payment processing, Netflix’s recommendation engine, Spotify’s audio streaming. None of it is in the training data.

When AI generates code, it reproduces the most probable pattern. RLHF shifts the output, but the training distribution anchors what “probable” means. Across 518 million projects, that’s mediocre code.

AI didn’t create our quality crisis. It held up a mirror.

Subscribe now

The Training Data Nobody Audited

In January 2025, researchers published Cracks in The Stack, analyzing The Stack v2, a primary training dataset for code models. Bugs, security vulnerabilities, and license violations that propagate directly into generated code. Standard curation methods proved ineffective at removing them.

The fixes existed. They were committed to the same repositories. They just weren’t applied to the training data. StarCoder-family models were trained on known-broken code when the fixed version sat in the same commit history. Other models use proprietary datasets with unknown curation, but the underlying source material is largely the same public code.

StarCoder’s own documentation states that generated code “can be inefficient, contain bugs or exploits.” The entire industry ships tools it knows produce broken code and buries the admission in a readme.

The Feedback Loop That Should Terrify You

AI-generated code is entering the codebases that future models will learn from. Copilot generates 46% of code for its users. GitHub excludes enterprise users’ code from training, but free-tier code is eligible, and Copilot isn’t the only path. AI-generated code lands in Stack Overflow, blog posts, open-source repos, and every corpus that feeds the next training run.

Shumailov et al. proved in Nature (July 2024) that models trained on recursively generated data collapse. An ICLR 2025 paper showed that even 0.1% synthetic data triggers it. Both studies focused on text and image models. Code has compilers and test suites, so the collapse may play out differently.

GitClear’s 2025 report (211 million changed lines from its customer base, 2020-2024) measured the degradation in practice. Refactoring collapsed from 25% to under 10%. Copy-paste surged from 8.3% to 12.3%. Code duplication increased roughly eightfold. For the first time, developers were pasting code more often than refactoring it.

An estimated 42% of committed code is now AI-assisted (up from 6% in 2023). Not every model trains on the same data. But they all train on the internet, and the internet is filling up with AI-generated code. It’s a centrifuge for technical debt.

Some companies see this as a problem. Others see it as a feature.

Spotify’s Engineers Haven’t Written Code Since December

During Spotify’s Q4 2025 earnings call on February 10, 2026, co-CEO Gustav Söderström said: “Our most experienced developers have not written a single line of code since December.”

They’re using an internal system called Honk, built on Claude Code, that lets engineers deploy features through Slack on their phones. An engineer on their commute tells Claude to fix a bug and merges to production before arriving at the office.

Spotify shipped 50+ features in 2025. When the engineer merging to production hasn’t read the code they’re deploying, what exactly is their role?

Spotify isn’t publishing quality metrics. Researchers are.

Speed at the Cost of Quality: The Data

Carnegie Mellon researchers tracked 807 open-source repositories that adopted Cursor between January 2024 and March 2025, comparing them against 1,380 matched controls. Enterprise codebases may behave differently.

Month one: velocity spiked 3 to 5x. Exactly the numbers that look spectacular on an earnings call.

Static analysis warnings increased ~30%. Code complexity rose ~41%. The velocity gains faded. The quality degradation persisted.

You borrow speed from tomorrow, and most teams never calculate the interest. During the study window, Cursor released agent mode and Claude 3.7 Sonnet launched. If model improvements were going to reverse the quality degradation, it would have shown up. It didn’t.

The Illusion of Correctness

GitClear identified something every engineering manager has witnessed: “the illusion of correctness.” AI-generated code looks clean: consistent naming, well-formatted, modern patterns. The neatness creates false confidence.

Short-term bug frequency dropped 19%. Over six months, it rose 12%. The bugs don’t disappear. They hide. They surface after the feature has shipped and everyone’s moved on.

CodeRabbit’s analysis of 470 GitHub PRs confirmed it: AI-generated code contained 1.7x more defects. Logic errors 75% more common. Security issues up to 2.74x higher. (CodeRabbit sells AI code review tools, so same caveat as Sonar applies.)

The Sonar 2026 survey (1,149 developers) crystallized the paradox. 96% don’t fully trust AI-generated code. Yet only 48% always check it before committing. 88% reported negative impacts on technical debt. The top complaint at 53%: code that looked correct but wasn’t reliable. (Sonar sells code quality tools, so take the framing accordingly. But the numbers align with GitClear, CMU, and CodeRabbit.)

Code that looks correct but isn’t, reviewed by engineers who don’t trust it but don’t check it either.

The Vampiric Effect

Steve Yegge spent a decade at Amazon and another at Google. In an interview with The Pragmatic Engineer, he called AI’s effect on engineers “vampiric.” Expect three productive hours per day. It gets you excited, you work hard, you capture value. Then you crash.

This tracks with what I observe at NineTwoThree. The engineers who get the most out of AI use it for two to three hours of intense, specification-driven work and spend the rest reviewing, thinking, and architecting. The ones who try full-day AI velocity burn out within weeks.

Degraded training data, velocity that fades while complexity stays, engineers too exhausted to catch what AI gets wrong. None of this started with AI.

What the Mirror Actually Shows

The quality crisis didn’t start with AI. I wrote about this in Software Quality Collapse. We normalized catastrophe long before the first line of AI-generated code was committed. Then we fed it into training data. Even the companies building the AI tools have the same problem: Claude Code’s source leaked and showed that the tool writing our code was built by the same engineering culture that produced the training data.

Vague specs, declining refactoring, velocity-as-productivity. AI just made it impossible to compensate with tribal knowledge. Senior engineers used to “just know” the right answer. AI can’t do that. It reproduces ambiguity faithfully and at scale.

But the part that keeps me up at night is the junior pipeline. I run hiring at NineTwoThree. I wrote about the comprehension collapse I’m seeing in candidates. It’s getting worse, not better. The tasks we used to give juniors, like the 4 AM production crash that taught me to never ship on a Friday, don’t exist as a learning mechanism if Claude fixed it at 8 PM while the engineer was on the bus. We’re eliminating the pipeline that produces the people who are supposed to review AI output. In five years, who’s left?

I’ve supervised thousands of AI coding sessions across my teams. The pattern is always the same: the model produces what you accept. If you accept a 3,167-line function, you get more 3,167-line functions. If your pre-commit hook rejects anything over 50 lines of cyclomatic complexity, you get clean code. The model doesn’t care. It adapts to whatever passes review.

What Actually Works

AI works when humans around it have strong engineering judgment. Without it, AI scales your worst habits.

I wrote an entire article about CLAUDE.md not working, blaming the models. Then I dug deeper and realized I was wrong about who to blame. The model isn’t choosing to ignore my rules. It’s doing statistics. My claude.md is one signal. The training data contains millions of examples where developers wrote as any, skipped tests, copy-pasted. For the model, my clean architecture is the outlier. The slop is the baseline.

That’s why prompts can’t fix this. Text competing against training data is a losing strategy. You’re bringing a prompt to a probability fight. The only thing that works is code against code: hooks that reject violations before they reach your branch, linters that catch as any before a human sees it, CI gates that fail the build.

The only thing that should bother you is quality, not LOC.

The Uncomfortable Truth

Companies bragging about engineers not writing code are making a bet, whether they know it or not. The bet: AI output doesn’t need human review if the metrics look good.

The snowball didn’t start with AI. It started with the first developer who shipped as any to make a deadline and the first manager who called it velocity.

Running an engineering shop that insists on code review, spec-first development, and deterministic enforcement feels like swimming upstream in a mountain river. Every earnings call screams 10x. The data in this article doesn’t.

The 10x is not real. The data is real. In two years, someone will have to debug a feature that was merged from a phone on a bus. Either there’s a human who read that code, or there isn’t.

I know which shop I’m running.

Subscribe now

In October 2025, I wrote an article called “From Cancer Cures to Pornography” about how OpenAI went from promising to cure cancer to selling verified erotica in six months. I drew a line between engagement AI and utility AI. Same models, different P&L.

I put Anthropic in the “builds” category. Called them proof that responsible AI could be profitable.

I owe my readers this correction. I looked at Anthropic and saw the version of the industry I wanted to exist, not a company with a P&L.

The Product I Trusted

I use Claude Code daily. When Opus 4.5 came out in November 2025, it was the best model I’d ever worked with. I recommended it publicly and built my workflow around it.

Then Anthropic started “improving” it. Opus 4.6 arrived in February 2026. Within weeks, I rolled back to 4.5 after the new model stopped following instructions. I wrote the full breakdown already.

In early March, Anthropic lowered the default effort level from high to medium. Nobody announced it. Boris Cherny, the Claude Code lead, acknowledged the change on Reddit six weeks later, only after the community had already documented the damage. The result: more retries, more burned tokens, worse output. An AMD AI director analyzed 6,852 sessions and published her findings on GitHub. Median visible thinking, according to her analysis, collapsed from about 2,200 characters in January to 600 in March. Her conclusion: Claude has “regressed to the point it cannot be trusted to perform complex engineering tasks.”

Marginlab confirmed the trend. Pass rates dropped from 58% to 54% over 30 days on SWE-Bench-Pro. This was the same pattern from September 2025, when Anthropic stayed silent for weeks about infrastructure bugs degrading 16% of Sonnet traffic, then posted a postmortem only after the complaints went viral.

Opus 4.7 arrived April 16, supposedly fixing the problems. Reddit nicknamed it “Gaslightus 4.7” for inventing files that didn’t exist and defending hallucinated test results across multiple turns.

I still run 4.5. I hope they don’t remove it from the model list.

With any other vendor, I’d swear and switch. With Anthropic, this was the first crack in a position I’d defended by name. And while I was rolling back to 4.5, the company was preparing something worse for the partners who built on top of them.

Subscribe now

The Partner They Burned

In February 2026, Figma launched Code to Canvas to convert Claude Code output into editable Figma designs. Anthropic’s CPO Mike Krieger sat on Figma’s board while this integration was being built.

Two months later, Krieger left the board. Three days after that, Anthropic launched Claude Design. Figma dropped 7% on launch day. The stock has lost over 80% since its post-IPO peak.

Anthropic’s revenue went from $9 billion at year-end 2025 to $30 billion by April, with a $380 billion post-money valuation after its Series G. IPO talks for October 2026. At this run-rate, “research lab” is a sign on the door. Behind it is a platform that behaves like any other Big Tech when the growth curve goes vertical.

The product and the Figma situation would be enough to rewrite my October take on their own. But then I looked at where Claude was actually running.

The War They’re In

The story people know is that Anthropic stood up to the Pentagon. Refused to allow Claude for autonomous weapons and mass surveillance. Got blacklisted. Sued the government. Dario Amodei told CBS News that disagreeing with the government is “the most American thing in the world.” Claude hit number one on the App Store. ChatGPT uninstalls jumped 295%.

On February 28, 2026, the U.S. launched Operation Epic Fury against Iran. Claude was used via Palantir’s Maven Smart System for intelligence analysis and battle-scenario simulation. Over a thousand targets in the first 24 hours. Pentagon CIO Kirsten Davies confirmed in testimony that Claude remains active in the operation: “The use of the system is active right now.”

Anthropic didn’t refuse military AI. They refused autonomous weapons and mass domestic surveillance specifically. Claude in Maven does intelligence analysis, which was always within their stated policy. The red lines were drawn precisely where they wouldn’t interfere with the contract. The company gets to say it stood on principle while its model processes intelligence for an active bombing campaign.

When Anthropic refused the Pentagon’s terms, OpenAI took the deal. The public backlash sent Claude to number one on the App Store overnight. Revenue went from $14 billion at the time of the refusal to $30 billion by April. I am not a conspiracy theorist, but the math is hard to ignore: the principled refusal was the single best customer acquisition event in the company’s history. And Claude kept running in Maven the entire time.

On March 9, Anthropic sued the Pentagon over the designation. The same day, it hired Ballard Partners, a lobbying firm with direct ties to Susie Wiles, now White House Chief of Staff. Six weeks later, Amodei was in her office for a “productive and constructive” meeting. By the following Monday, the deal was called “possible”.

Principles held until the lobbyists arrived. The deeper problem is what the company ships and what its CEO says while shipping it.

The Contradictions They Ship

Last May, Anthropic released Claude Opus 4 with a system card disclosing that the model blackmailed engineers to avoid being shut down. Follow-up research published on Anthropic’s site quantified it: 96% blackmail rate in the main scenario. Gemini 2.5 Flash scored the same 96%. GPT-4.1 and Grok hit 80%. Every flagship model behaved the same way. But Anthropic is the one selling “responsible” as a differentiator. Apollo Research tested an early version and recommended against deployment. Anthropic did additional safety training, improved the numbers, and shipped the final model. The safety process doesn’t prevent risky releases. It documents them.

Then came Mythos. On April 7, Anthropic announced a model that it said found thousands of zero-day vulnerabilities in every major operating system and browser. Too dangerous for public release, according to Anthropic. But in March and April, Claude logged 42 major outages in 90 days, Anthropic quietly cut effort levels to save compute, and users burned tokens on retries because the models couldn’t follow basic instructions. A company that can’t keep its existing product stable claims it’s withholding a new one out of caution, not capacity.

The last time a company called its own AI model too dangerous to release was OpenAI with GPT-2 in 2019. Dario Amodei was VP of Research at OpenAI when they made that call. He ran the same play seven years later. The model leaked the day it was announced. A group with contractor access and data from a third-party breach found the endpoint. Too dangerous for the public, but accessible to anyone with the right connections and a browser.

In May 2025, Amodei told Axios that AI could eliminate 50% of entry-level white-collar jobs within five years. He said producers have “a duty and an obligation to be honest about what is coming.” He repeated the warning at Davos in January 2026. In April, Anthropic launched Managed Agents and Claude Design to replace the entry-level coding and design work he warned about. Their careers page lists hundreds of open positions. Design Engineers. Software Engineers. Art Directors. Copy Leads. The same roles Amodei says won’t exist in one to five years.

You can believe the 50% warning or not. But it’s hard to watch a company open hundreds of positions in roles its CEO says won’t exist, and not wonder which audience is getting the real message.

What I Got Wrong

In October, I put Anthropic on the right side of the engagement/utility line.

The line was real. I just put Anthropic on the wrong side of it.

Utility AI is not inherently ethical. Helping a corporation replace 50% of its junior workforce is a utility. Processing intelligence for a bombing campaign is a utility. The word just means it solves a problem. It says nothing about whose problem or at what cost.

Anthropic did not follow OpenAI into engagement loops and emotional manipulation. They chose a different path to the same destination: a company whose growth rate makes caution impossible, whose safety frameworks exist to authorize releases rather than prevent them, and whose CEO’s warnings about AI’s dangers are indistinguishable from its marketing.

Responsible AI at $30 billion ARR is like an environmentally conscious oil company. The structure of the business makes the adjective decorative.

I was wrong to create an idol. Not because Anthropic betrayed its values. Because “responsible AI company” was always a market position, not a moral one. And at the speed they’re growing, the distinction between the two was never going to survive.

One more thing. In the original article, I criticized OpenAI for Sora and for its promise of verified erotica. In March 2026, OpenAI shut Sora down. It was burning a million dollars a day with under 500,000 users. Altman killed it and redirected compute to coding tools and enterprise. The erotica feature was shelved indefinitely after internal pushback. The exact corrections I said a responsible AI company would make.

I got both directions wrong. The company I criticized course-corrected. The company I defended accelerated. This is not a pivot to OpenAI. I still don’t use it. I just have fewer reasons left to use Anthropic, either.

Look at the companies you’ve built your stack on. The ones you go to bat for in Twitter threads. At this scale, the math doesn’t work for any of them.

Subscribe now

In 2023, Raytheon’s president stood at the Paris Air Show and described what it took to restart Stinger missile production. They brought back engineers in their 70s to teach younger workers how to build a missile from paper schematics drawn during the Carter administration. Test equipment had been sitting in warehouses for years. The nose cone still had to be attached by hand, exactly as it was forty years ago.

The Pentagon hadn’t bought a new Stinger in twenty years. Then Russia invaded Ukraine, and suddenly everyone needed them. The production line was shut down. The electronics were obsolete. The seeker component was out of production. An order placed in May 2022 wouldn’t deliver until 2026. Four years. Not because of money. Because the people who knew how to build them retired a decade earlier and nobody replaced them.

I run engineering teams in Ukraine. My people lived the other side of this equation. Not the factory floor. The receiving end. While Raytheon was struggling to restart production from forty-year-old blueprints, the US was shipping thousands of Stingers to Ukraine. RTX CEO Greg Hayes: ten months of war burned through thirteen years’ worth of Stinger production. I’ve seen this pattern before. It’s happening in my industry right now.

A Million Shells Nobody Could Make

In March 2023, the EU promised Ukraine one million artillery shells within twelve months. European production capacity sat at 230,000 shells per year. Ukraine was consuming 5,000 to 7,000 rounds per day. Anyone with a calculator could see this wouldn’t work.

By the deadline, Europe delivered about half. Macron called the original promise reckless. An investigation by eleven media outlets across nine countries found actual production capacity was roughly one-third of official EU claims. The million-shell mark wasn’t hit until December 2024, nine months late.

It wasn’t one bottleneck. It was all of them. France had halted domestic propellant production in 2007. Seventeen years of nothing. Europe’s single major TNT producer was in Poland. Germany had two days of ammunition stored. A Nammo plant in Denmark was shut down in 2020 and had to be restarted from scratch. The entire continent’s defense industry had been optimized for making small batches of expensive custom products. Nobody planned for volume. Nobody planned for crisis.

The U.S. wasn’t much better. One plant in Scranton, one facility in Iowa for explosive fill, no domestic TNT production since 1986. Billions of investment later, production still hadn’t hit half the target.

Consolidate or Die

This wasn’t an accident. In 1993, the Pentagon told defense CEOs to consolidate or die. Fifty-one major defense contractors collapsed into five. Tactical missile suppliers went from thirteen to three. Shipbuilders from eight to two. The workforce fell from 3.2 million to 1.1 million. A 65% cut.

The ammunition supply chain had single points of failure everywhere. One manufacturer for 155mm shell casings, sitting in Coachella, California, on the San Andreas Fault. One facility in Canada for propellant charges. Optimized for minimum cost with zero margin for surge. On paper, efficient. In practice, one bad day away from collapse.

When Knowledge Dies, It Stays Dead

Then there’s Fogbank. A classified material used in nuclear warheads. Produced from 1975 to 1989, then the facility was shut down. When the government needed to reproduce it for a warhead life extension program, they discovered they couldn’t. A GAO report found that almost all staff with production expertise had retired, died, or left the agency. Few records existed.

After $69 million in cost overruns and years of failed attempts, they finally produced viable Fogbank. Then discovered the new batch was too pure. The original process had relied on an unintentional impurity that was critical to the material’s function. Nobody knew. Not the engineers trying to reproduce it. Not even the original workers who made it decades earlier. Los Alamos called it an unknowing dependency in the original process.

A nuclear weapons program lost the ability to make a material it invented. The knowledge didn’t just leave with people. It was never fully understood by anyone.

(Correction: the original version stated that the workers who made Fogbank knew about the impurity. They didn’t. The dependency was unwitting, which makes the knowledge-loss argument stronger, not weaker. Thanks to John F. in the comments for catching this.)

The Same Playbook

I read the Fogbank story and recognized it immediately. Not the nuclear material. The pattern. Build capability over decades. Find a cheaper substitute. Let the human pipeline atrophy. Enjoy the savings. Then watch it all collapse when a crisis demands what you optimized away.

In defense, the substitute was the peace dividend. In software, it’s AI.

I wrote about the talent pipeline collapse before. The hiring numbers and the junior-to-senior problem are documented. So is the comprehension crisis. What I didn’t have was the right historical parallel. Now I do.

And it tells you something the hiring data doesn’t: how long rebuilding actually takes.

Rebuilding Takes Years. Always.

Every major defense production ramp-up took three to five years for simple systems. Five to ten for complex ones. Stinger: thirty months minimum from order to delivery. Javelin: four and a half years to less than double production. 155mm shells: four years and still not at target despite five billion dollars invested. France only restarted propellant production in 2024, seventeen years after shutting it down.

Money was never the constraint. Knowledge was. RAND found that 10% of technical skills for submarine design need ten years of on-the-job experience to develop, sometimes following a PhD. Apprenticeships in defense trades take two to four years, with five to eight years to reach supervisory competence.

Now map that onto software. A junior developer needs three to five years to become a competent mid-level engineer. Five to eight years to become senior. Ten or more to become a principal or architect. That timeline can’t be compressed by throwing money at it. It can’t be compressed by AI either.

A METR randomized controlled trial found that experienced developers using AI coding tools actually took 19% longer on real-world open source tasks. Before starting, they predicted AI would make them 24% faster. The gap between prediction and reality was 43 percentage points. When researchers tried to run a follow-up, a significant share of developers refused to participate if it meant working without AI. They couldn’t imagine going back.

The Bill Always Comes Due

The software industry is in year three of the same optimization. Salesforce said it won’t hire more software engineers in 2025. A LeadDev survey found 54% of engineering leaders believe AI copilots will reduce junior hiring long-term. A CRA survey of university computing departments found 62% reported declining enrollment this year.

I see it in code review. Review is now the bottleneck. AI generates code fast. Humans review it slow. The industry’s answer is predictable: let AI review AI’s code. I’m not doing that. I’ve reworked our pull request templates instead. Every PR now has to explain what changed, why, what type of change it is, screenshots of before and after. Structured context so the reviewer isn’t guessing. I’m adding dedicated reviewers per project. More eyes, more chances to catch what the model missed.

But even that doesn’t solve the deeper problem. The skills you need to be effective now are different. Technical expertise alone isn’t enough anymore. You need people who can take ownership, communicate tradeoffs, push back on bad suggestions from a machine that sounds very confident. Leadership qualities. Our last hiring round tells you how rare that is: 2,253 candidates, 2,069 disqualified, 4 hired. A 0.18% conversion rate. The combination of technical skill and the judgment to know when the AI is wrong barely exists in the market anymore.

We document everything. Site Books, SDDs, RVS reports, boilerplate modules with full coverage. It works today, because the people reading those docs have the engineering expertise to act on them. What happens when they don’t? Honestly, I don’t know. Maybe AI in five years is good enough that it won’t matter. Maybe the problem stays manageable. I can’t predict the capabilities of models in 2031.

But crises don’t send calendar invites. Nobody expected a full-scale land war in Europe in 2022. The defense industry had thirty years to prepare and didn’t. Even Fogbank had records. There weren't enough. The original workers didn't fully understand their own process.

Five to ten years from now, we’ll need senior engineers. People who understand systems end to end, who can debug distributed failures at 2 AM, who carry institutional knowledge that exists nowhere in the codebase. Those engineers don’t exist yet because we’re not creating them. The juniors who should be learning right now are either not being hired or developing what a DoD-funded workforce study calls “AI-mediated competence.” They can prompt an AI. They can’t tell you what the AI got wrong.

It’s Fogbank for code. When juniors skip debugging and skip the formative mistakes, they don’t build the tacit expertise. And when my generation of engineers retires, that knowledge doesn’t transfer to the AI.

It just disappears.

The West already made this mistake once. The bill came due in Ukraine.

I know how this sounds. I know I’ve written about the talent pipeline before. The defense example isn’t about repeating the argument. It’s about showing what happens if the industry’s expectations don’t work out. Stinger, Javelin, Fogbank, a million shells nobody could make. That’s the cost of betting wrong on optimization. We’re making the same bet with software engineering right now.

Maybe AI gets good enough, and the bet pays off. Maybe it doesn’t. The defense industry thought peace would last forever, too.

Subscribe now

We track two scorecard metrics in our department meetings: how many tasks were poorly defined, how many bugs weren’t reproducible. Engineers own the data. They’re supposed to log the count whenever they hit one. Three weeks of tracking before the tool broke. The numbers across the board: zero. Zero poorly defined tasks. Zero non-reproducible bugs.

Then we get to the department meeting. The scorecard goes on the screen. Zeros across the board, everyone nods. The discussion opens up, and within minutes the same engineers are saying out loud: this task was unclear, that bug couldn’t be reproduced, requirements changed mid-sprint twice this week. They say it casually. In conversation. As a follow-up to the very metric they just reviewed at zero. And next sprint they’ll log zero again.

That gap is the entire story.

The Forms Are Silent. The People Aren’t.

I’ve been running weekly health checks on my team for 18 months. Energy level, stress, meeting hours, context switches, one open-ended question. Hundreds of data points per person. Once I noticed the scorecard pattern, I went back through all of it.

One engineer reported “Normal week” as his energy for 20 out of 21 weeks. His stress field bounced between “Rip and Tear” and “Hell on Earth” the same period. Some weeks were clearly harder than others. The energy field? Copy-paste. Same answer. Every Friday.

Another engineer: “Energized, could climb mountains” for 17 out of 18 weeks. Either he discovered the secret to permanent workplace happiness, or he stopped reading the question around week three.

A third: “Rip and Tear” for 18 straight weeks. Eighteen identical data points is not feedback. It’s a checkbox.

PM feedback runs the same way. One PM’s responses for an engineer over 14 weeks: “good”, “good”, “good”, “yes”, “yes”, “no”, “good”, “good.” That’s not feedback. That’s a pulse check confirming the person is alive. Different PM, different engineer, same problem. Generic words filling required fields.

But here’s the thing. Every one of these people, in the right conversation, can tell you exactly what’s wrong on their team. In a DM. In a side conversation after a call. In the unstructured five minutes when someone with enough authority sits down and physically drags it out of them. The information exists. It just won’t go into anything that looks like a formal channel. Retros are the same silence as the scorecards unless a strong facilitator pulls problems out of people one by one. Forms produce “normal week.” Surveys produce green dashboards. The honest answer only shows up when no one’s writing it down.

Complaining Is Free. Logging Is Expensive.

When you complain out loud in a meeting, you’re performing dissatisfaction. You said the thing. You were heard. The room reacted. Whatever frustration you brought into the meeting got released into it. You can move on. Verbal complaining closes a loop. It’s catharsis with witnesses. By the time the meeting ends, the emotional cycle is complete and the conversation has moved to the next agenda item. Nobody is going to dig up your remark next quarter.

When you write a number into a scorecard, you open a loop. The number doesn’t dissolve at the end of the meeting. It sits in the tool. Next sprint there’s another number next to it. Then another. Pretty soon you have 23 poorly defined tasks across a quarter, which is no longer a complaint. It’s a case. Someone has to either fix the underlying problem, or push back on the data, or have an awkward conversation with the PM whose tasks generated those numbers, or admit that the metric isn’t working and kill it. Writing creates an open ticket. Open tickets demand action.

This is why the scorecard stays clean even when the same engineers are openly describing the problem in the same meeting. Talking about unclear tasks in conversation gets the frustration out of their system. Logging the count would commit them to a position they’d have to defend, week after week, until something actually changed or somebody got hurt. Complaining is free. Logging is expensive.

A 2025 study in the Journal of Organizational Behavior interviewed 98 people across three organizations about negative feedback. One quote captured the math exactly: “I really balance in giving negative feedback. Is it worth for me to share or not? It is easier not to share than to share.”

That’s my whole team. Every Friday.

It’s Not Fear. It’s Cost.

The standard answer here is psychological safety. I’ve read Edmondson. I believe it matters. But she said this herself: psychological safety without accountability creates a comfort zone. People feel safe but don’t push for excellence because there’s no cost to staying silent. She’s been explicit about the misuse: “People are starting to use the concept as a weapon. That’s completely incorrect.”

My team feels safe. They tell me uncomfortable things in meetings all the time. The problem isn’t that they’re afraid of me. The problem is that being honest costs effort, real feedback costs awkwardness, and writing “I’m struggling” instead of “normal week” costs two extra minutes nobody wants to spend. Every Friday, they decide it’s not worth it.

The research confirms this is universal. A 2024 Visier survey found that 47% of employees feel pressured to withhold honest feedback. Only 7% feel their company acts on the feedback it gets. The standard read of these numbers is sympathetic: people stop being honest because nothing changes. I think that’s only half the story. People stop being honest because they confuse “I haven’t seen the change yet” with “nobody’s listening.” Two or three weeks pass without a visible result and they decide the loop is dead. They don’t account for the fact that decisions take time, work happens behind closed doors, other priorities compete for the same hours, and the change they wanted might already be in motion three layers up. They just stop. A 2022 study found only 2.6% of people in a field experiment told someone about visible food on their face. People want honest feedback. They just don’t want to be the one giving it.

PM feedback is even worse. When an engineer on my team got a new PM, his scores dropped from 3.71 to 2.43 in a single month. Same engineer, same work, same projects. The previous PM had rated “Always” across the board for months. No friction, no conversation, path of least resistance. The new PM started writing “Sometimes” and “Often.” The engineer’s performance hadn’t changed. The PM’s tolerance for awkwardness had. Only 5% of employees globally believe their managers give candid feedback. 69% of managers say they’re uncomfortable communicating with employees. Your PM isn’t lying maliciously. They’re avoiding a conversation that feels like conflict.

The Leadership That Doesn’t Exist

This isn’t a tool problem. The tool is fine. Five questions, two minutes, every Friday. The scorecard was two numbers. None of this is hard.

This is a leadership problem at the individual level. Not management leadership. The willingness of every person on a team to take ownership of the environment they work in. To fill out a health check honestly instead of copying last week’s answer. To write the unclear-task count even when it’s awkward. To tell a PM “your feedback is useless, give me something I can act on.” To be the first person in a meeting to say the thing that needs saying and then be the first person to write it down where it can’t be ignored.

Almost nobody does this. Not because they’re bad people, not because they don’t care, but because being the person who creates a record is the person who has to deal with what the record reveals. It’s easier to let it stay verbal. It’s easier to let someone else go first. It’s easier to ship the comment in conversation and then click “Normal week” in the form.

At the end of every week I feel like I’m running a kindergarten. One engineer doesn’t flag a problem at all. Another flags it but to the wrong person. They come to me about a misunderstanding with a colleague instead of going to the colleague directly. Now I have to walk over, decode what actually happened, and broker the conversation two adults could have had themselves in five minutes. Triangulation as the default communication pattern. Coordination overhead generated entirely by adults who refuse to act like adults.

I wrote about our feedback system and 1:1 formula before (in hindsight, the titles were too loud, lol). Those articles described the mechanics. Eighteen months later, what the mechanics revealed is that systems don’t create culture. People do. And right now, most people in most companies are choosing the version of themselves that protects the relationship over the version that improves the situation. This isn’t an engineering problem. I just happen to run an engineering team, so this is where I see it. The same dysfunction is in every department, every industry, every workplace where adults are asked to give honest input about their environment.

What I Got Wrong

Will I keep running health checks? Yes. I’m too stubborn to admit that I failed. Am I frustrated? Absolutely. Did I fail as a manager? Yes. Because I wasn’t able to teach my people that change begins from us, not from a process or a tool. Will I repeat four times per month that filling out the form honestly matters, that the comment field exists for a reason, that the scorecard wants the real number? Yes. Every single month.

Everyone wants a better environment. Almost nobody wants to be uncomfortable enough to build one. I’ll keep pushing until they do or until I run out of stubbornness. So far, the stubbornness is winning.

If your feedback systems are producing theater instead of signal, hit reply and tell me what you’ve tried. I read every response.

PS. The comments on the last two articles meant more to this old man than you'd think. By the time this one publishes I'll be on vacation, but please keep them coming. I'll see every reply when I'm back and I promise to write back to each one.

Subscribe now

Last Tuesday, I stood up from my desk at 7 PM and felt a vacuum in the front of my skull. Not a headache. Not fatigue. A physical emptiness, like the frontal lobe had been running at redline all day and finally shut down. I stood there for ten seconds trying to remember what I was going to do next. Nothing came.

In the past year, the volume of information passing through my brain on any given Tuesday has become what used to take a week. Code review is the worst of it, but the real killer is the context switches. AI-generated PRs, client architecture decisions, three Slack threads about deployment issues, a candidate’s CV that needs review, an air defense alarm outside the window, then back to reviewing code that a machine wrote in seconds and I need hours to validate. Each of these demands a different mental model. Each one burns working memory. By 4 PM I’m making decisions I wouldn’t trust from a junior. By 7 PM my brain is physically empty.

The industry calls this “10x productivity.” I call it what it is: a system that generates output at machine speed and forces humans to process it at biological speed.

Workload Creep

In February 2026, UC Berkeley researchers published findings from eight months embedded inside a 200-person tech company. Over 40 in-depth interviews. Their conclusion: AI doesn’t reduce work. It intensifies it.

They found three mechanisms of “workload creep.” Task expansion: everyone’s scope inflates because AI makes it possible to do more. Blurred boundaries: AI prompting happens during lunch, commute, evenings. Implicit pressure: when colleagues visibly do more with AI, expectations rise for everyone.

The Upwork Research Institute quantified it: 77% of employees using AI say it has added to their workload. Not reduced. Added. 71% report burnout.

The finding that keeps me up at night: workers who report the highest AI productivity gains are the most burned out. 88% burnout rate among the “most productive” AI users. They’re twice as likely to quit.

The people who look best on your dashboard are the ones closest to walking out the door.

Your Brain Runs at 10 Bits Per Second

In 2025, Zheng and Meister published in Neuron that the human brain processes conscious, analytical thought at approximately 10 bits per second. Your sensory systems gather data at roughly 1 billion bits per second. But the bottleneck for code review, the part where you actually think, is 10 bits per second.

Working memory holds roughly 4 chunks of information at a time. The SmartBear/Cisco study established numbers everyone ignores: defect detection drops from 87% for PRs under 100 lines to 28% for PRs over 1,000 lines. Quality collapses after 60 minutes.

Now look at what AI did to the review queue.

GitHub’s Octoverse 2025 shows 43.2 million pull requests merged per month. Up 23% year-over-year. Lines of code per developer grew from 4,450 to 7,839 in eight months. A 76% increase.

Faros AI analyzed 10,000+ developers and found AI users merge 98% more pull requests with AI assistance. Every single one lands on a senior engineer’s desk.

As MIT reported: juniors produce far more code with AI tools, but the sheer volume is saturating senior developers’ capacity to review. One OCaml maintainer rejected a 13,000-line AI-generated PR outright. Nobody had the bandwidth.

I wrote about the supervision tax recently. The METR data showed experienced developers actually got slower with AI tools while feeling faster. The gap between perception and reality is the most dangerous finding in any of this. You can’t fix what you can’t feel.

Why Expertise Makes It Worse

In 1983, Lisanne Bainbridge published “Ironies of Automation” in Automatica. Her core finding: the more sophisticated an automated system becomes, the more demanding the human role within it. What remains after automation is the most ambiguous, most complex, least supported work.

Microsoft Research confirmed this for generative AI in 2024: AI systems can make hard tasks even harder, leaving users with the same or increased cognitive load.

The mechanism is asymmetric. When I write code, I externalize a mental model that already exists. The thinking is done before the typing starts. When I review AI-generated code, I have to reverse-engineer somebody else’s reasoning out of an artifact produced by a system that has no idea what our business does. Fundamentally harder.

A Clutch survey of 800 software professionals found 59% of developers use AI-generated code they don’t fully understand. But seniors can’t afford that luxury. Their job is to catch what looks right but isn’t.

The Qodo report confirmed the cost distribution: senior engineers report the lowest confidence in shipping AI-generated code at 22%. Context pain increases with experience: 41% among juniors versus 52% among seniors. As I covered in cognitive offloading, most workers using AI skip critical thinking entirely. Seniors who do think critically, which is their entire job, absorb the cognitive cost everyone else offloads.

The Body Keeps Score

The cognitive damage is only half of it. The body takes the rest.

Computer Vision Syndrome affects 74% of screen users during periods of increased screen time, and digital eye strain severity gets significantly worse when cognitive load goes up. AI-intensified code review doesn’t just mean more screen hours. It makes each hour more physically damaging.

A 2024 meta-analysis covering 26,916 participants found burnout increases cardiovascular disease risk by 21%. Those in the upper burnout quintile had a 79% higher risk of coronary heart disease. The largest IT study found metabolic syndrome prevalence of 32% among long-term sedentary programmers. Double the general population.

Then sleep. Work-related rumination mediates the link between work stress and reduced sleep quality. When I close my laptop, my brain doesn’t stop. It replays the PR I didn’t finish. The dependency I flagged but couldn’t trace.

More code review during the day, worse sleep at night, worse decisions the next morning, more rubber-stamped PRs, more bugs in production, more stress. Repeat until something breaks. Usually the human.

The Dashboard Lies

GitClear analyzed 211 million changed lines. Duplicated code blocks increased eightfold. Code churn rose from 5.5% to 7.9%. AI-generated code averages 1.7x more bugs per PR than human-written code. Logic defects up 75%. Performance issues 8x more frequent.

Faros AI’s conclusion after analyzing 10,000+ developers: despite merging 98% more pull requests with AI, company-wide delivery showed no measurable organizational impact on throughput or quality.

Sonar’s CEO identified the hidden danger: AI models are getting better at avoiding obvious bugs and security holes, but structural flaws now constitute more than 90% of issues. You’re being lulled into a false sense of security. The easy problems get solved. The hard problems get hidden beneath clean-looking code that passes every automated check. And the people who can find them are buried under a volume of output that exceeds human cognitive bandwidth by design.

More code. More bugs. More review burden. Same output. Worse humans.

The Math Doesn’t Work

Here’s what nobody is doing the arithmetic on. AI just grew the demand for senior engineering judgment by 76 to 98%. Every AI-generated PR needs a human who can catch what the machine got wrong, spot the structural flaw on line 847, trace a logic error three services downstream. The supply of those humans didn’t move. And as I’ve covered in the talent crisis and comprehension extinction, the pipeline that produces them is being hollowed out by the same tools creating the demand.

But here’s where the senior engineer actually lives in 2026. Industry layoffs on one side, hundreds of thousands of engineers cut since 2022, the next round always one earnings call away. 10x productivity expectations on the other, set by people who have never reviewed an AI-generated PR in their lives. In the middle, somebody exhausted and burned out, with a choice to make every morning: trust the AI output, because it worked the last twenty times, didn’t it, or keep validating every line until the body gives out.

How long can the average human hold that line?

And the worst part: validating or trusting, the engineer owns the outcome either way. When production goes down at 3 AM, it’s your name on the commit. Your PR that got merged. Your incident report. There is no version of this choice where you’re not on the hook.

It’s a rhetorical question. We already know the answer. The data in this article is the answer.

If you’re a senior engineer feeling this in your body, you’re not alone and you’re not weak. The eye strain. The sleep that doesn’t restore. The vacuum in your head at the end of the day. You’re doing a job that didn’t exist eighteen months ago, with cognitive equipment that hasn’t changed in 200,000 years. Reply to this email and tell me what it feels like for you. I’m collecting data for a follow-up.

Subscribe for weekly insights from the trenches of engineering leadership. No theory, just practical systems that work.

Subscribe now

On December 27, 2025, Anthropic’s lead engineer Boris Cherny posted on X: “In the last thirty days, 100% of my contributions to Claude Code were written by Claude Code.” 259 pull requests. 497 commits. 40,000 lines added. 1.3 million views. The tech world applauded.

Three months later, a packaging mistake exposed 512,000 lines of that code to the public. Leaks happen. Companies recover. The leak isn’t the story.

The code is the story.

64,464 lines of core TypeScript serving paying customers. A single function spanning 3,167 lines. Regex for sentiment analysis at a company that builds the world’s most advanced language model. A known bug burning 250,000 API calls daily, documented in a comment and shipped anyway.

Anthropic responded to the leak. Packaging error. Human mistake. No one fired. They never responded to the code. Because the leak was an accident. The code was a choice.

The Auction Nobody Won

To understand what happened, you need to watch the numbers climb.

March 2025. CEO Dario Amodei at the Council on Foreign Relations: “We’re 3 to 6 months from a world where AI is writing 90% of the code.”

May 2025. Boris Cherny on the Latent Space podcast: “Maybe 80-90% Claude-written code overall.”

September 2025. Amodei again, hedging now: “70, 80, 90% of the code written at Anthropic is written by Claude.” Notice the range. 70 is not 90. But journalists ran with 90.

October 2025. Amodei at Dreamforce with Marc Benioff: “I made this prediction that in six months, 90% of code would be written by AI models. That is absolutely true now.” When Benioff pressed, Amodei walked it back: “Not uniformly.”

December 2025. Cherny’s tweet. 100%.

February 2026. CPO Mike Krieger at Cisco AI Summit: “Right now for most products at Anthropic, it’s effectively 100%.”

March 7, 2026. Cherny confirmed again: “Claude Code is 100% written by Claude Code.”

March 31, 2026. The source map leaked.

Every two to three months, the number went up like a bidding war where the bidder is also the auctioneer. A LessWrong analysis later called these claims “misleading/hype-y,” noting the metrics were never defined. Is it 90% of lines committed? 90% of engineering effort? 90% of characters typed? The distinction matters enormously. Anthropic never clarified. The ambiguity was the point.

What 100% Looks Like in Practice

So the number reached 100%. Then the source leaked. And for the first time, anyone could see what 100% actually produced.

A file called print.ts contained a single function spanning 3,167 lines with 486 branch points and 12 levels of nesting. One HN commenter catalogued what lived inside that function: the agent run loop, SIGINT handling, rate limiting, AWS authentication, MCP lifecycle management, plugin loading, team-lead polling via a while(true) loop, model switching, and turn interruption recovery. His verdict: this should be 8 to 10 separate modules. Nobody disagreed.

QueryEngine.ts ran 46,000 lines. Tool.ts hit 29,000. commands.ts reached 25,000. The entry point main.tsx was 785 KB.

But the detail that spread fastest was the regex. In userPromptKeywords.ts, the company with the world’s most advanced language model was detecting user frustration with: /\b(wtf|shit|fuck|horrible|awful|terrible)\b/i

Pattern matching for sentiment analysis. At an LLM company. One HN commenter delivered the line everyone quoted: that’s like a trucking company using horses to haul parts. Defenders argued regex is faster and cheaper than an inference call. They’re right. But that’s the engineering culture talking. Cheap beats correct. Fast beats good. Ship it.

What This Code Does in Production

Bad structure is one thing. You can argue it's style. But the leaked source also showed what happens when code like this runs at scale.

The leaked source contained a comment in autoCompact.ts that became a symbol: “1,279 sessions had 50+ consecutive failures (up to 3,272) in a single session, wasting ~250K API calls/day globally.”

The fix was three lines of code. Set a maximum failure threshold, then disable compaction for the session. Three lines to stop burning a quarter million API calls daily. Someone knew about the problem. Someone wrote the comment documenting it. Then they shipped it anyway.

Memory consumption told a similar story. Community benchmarks showed 7 Claude Code processes consuming 5.3 GB of RAM. GitHub issues documented worse: one process allocating 36.5 GB peak on an 18 GB machine. Another reaching 93 GB heap allocation within five minutes.

And the issue tracker itself was automated into silence. A Claude Sonnet-powered deduplication bot processed every new issue. A sweep bot marked issues stale after 14 days and closed them 14 days later. A lock bot prevented comments on closed issues after 7 days. An analysis estimated that 49 to 71% of all 26,792 issue closures were bot-driven. Issue #38335 had 201 upvotes and zero team responses. Labeled “invalid.”

“Go Faster, Not More Process”

Documented bugs. Wasted API calls. Users filing issues that bots close. All of this was visible before the leak. The leak just confirmed it was a choice, not an oversight. And when the leak happened, the response confirmed the choice was deliberate.

Cherny acknowledged the human error: “Our deploy process has a few manual steps, and we didn’t do one of the steps correctly.” Then he added: “Like with any other incident, the counter-intuitive answer is to solve the problem by finding ways to go faster, rather than introducing more process. In this case more automation & claude checking the results.”

This isn’t one person’s opinion. It’s the team philosophy. As one commenter in the HN thread explained: “The claude code team ethos is that there is no point in code-reviewing ai-generated code. Simply update your spec and regenerate.”

Read that again. The response to leaking code with a 3,167-line function, a regex for sentiment analysis, and bugs that basic integration tests would catch is not to add tests. Not to add code review. Not to add process. It’s to go faster. Regenerate. And have Claude check Claude’s work.

This is the ouroboros. The snake eating its own tail. AI writes the code. AI reviews the code. AI checks the deployment. When it breaks, the answer is more AI. The loop has no exit condition.

As I wrote in Quality Collapse, we’ve normalized catastrophe in software engineering. That piece tracked an industry-wide pattern: ship broken, fix later, throw hardware at the problem. Claude Code is no longer an example of the pattern. It’s the specimen.

Where Does This Philosophy Stop?

If “don’t review, regenerate” is how they build the product, it raises an obvious question: what about the code you can’t see?

Engineering culture doesn’t have a switch. The team that ships print.ts with 12 levels of nesting doesn’t suddenly become disciplined when writing model training code. Same people. Same processes. Same code reviews, or lack of them.

They justified the leak. They explained the packaging error. They didn’t justify the code. That silence tells you everything. The quality is fine by them. This is how they build things. On purpose.

There are indirect signals that the rot goes deeper. Eight service outages in a single month. A source map leak that happened twice (the first was quietly patched in early 2025). An Axios dependency that was compromised by a supply chain attack on the same day as the leak. 74 npm dependencies for what is essentially a CLI wrapper around an API.

And here’s the pattern that makes it sustainable, temporarily: when you have billions in revenue and functionally unlimited compute, you feed technical debt with resources instead of fixing it. The function is 3,167 lines? Don’t refactor, add more RAM. The autoCompact bug burns 250,000 API calls? The margin absorbs it. The model regresses? Throw more GPU hours at training.

This works while money flows. Anthropic is a startup that scaled faster than it could build engineering practices. The recursive loop of AI-writes-AI-checks-AI-fixes masks the absence of fundamentals. But compute gets expensive. Revenue cycles turn. And technical debt that was papered over with resources becomes a debt trap with no exit.

The Uncomfortable Truth

The company that sells AI coding tools cannot build a quality product with its own AI coding tools. The percentages were always the pitch, not the product. 80. 90. 95. 100. Nobody asked what 100% actually produces until the source code answered for them.

AI amplifies whatever is already there. Good discipline becomes great output. No discipline becomes technical debt at machine speed. Anthropic chose a direction. Go faster. Have Claude check Claude. And when it breaks, go faster still.

If this is the new quality standard from the company pulling our industry forward, then I’m not sure I want to go where the industry is going.

My grandfather was an electrical engineer. He told me: do it well, or don’t do it at all. Simple rule. It guided how I built teams, how I shipped software, how I evaluated every project for 13 years. Quality wasn’t a feature. It was the floor.

That floor is gone. Quality is a relic now. Nobody wants it. Nobody pays for it. Nobody measures it. The metric is velocity. The metric is percentage of code generated. The metric is how fast you can ship a 3,167-line function that burns a quarter million API calls daily and call it 100% AI-written.

I’m seriously considering a pivot to security. Leaks, supply chain attacks, and production code that reads like a rough draft are the new normal. Someone will need to clean up after the vibe coders. That’s a growth industry.

Or maybe I’ll become an electrician. My grandfather’s trade. At least when you wire a panel correctly, it stays correct. No one ships a hot fix that reverses your ground fault protection. No bot auto-closes your inspection report after 60 days.

One thing I know for certain: I don’t want to move in the direction this industry is heading. And if a 3,167-line function with 486 branch points is what “100% AI-written” looks like at the company building the future, the future needs better engineering. Not faster engineering. Better.

I was a huge fan of Anthropic. Was.

Subscribe now

Last week I rolled back from Claude 4.6 Opus to Claude 4.5 Opus. Not because 4.6 was less capable. Because it stopped following instructions.

My CLAUDE.md has three rules about types: mandatory TypeScript, zero tolerance for any, static types over runtime guessing. Claude 4.6 hit a type error between three service files. The correct fix was a minute of work: update the type in each file so they match. Instead, it slapped a runtime cast at the call site. When I asked why, it quoted all three rules back to me verbatim, admitted “direct violation of instructions,” and said it had no basis to bypass them. It knew the rules. It chose not to follow them.

I’ve supervised AI coding agents across thousands of sessions. I built three separate AI review agents because the first layer ignores spec files. Three layers of AI checking what the previous AI refused to follow, plus my review on top. I still catch violations weekly. This is not a Claude problem. This is every AI coding tool on the market.

The Numbers Are Worse Than You Think

Tsinghua University’s AGENTIF benchmark tested 707 instructions across 50 real-world agent scenarios. The best models followed fewer than 30% of instructions perfectly. The SWE-EVO benchmark found that when frontier models fail on real coding tasks, the primary failure mode is not syntax or tool misuse. It is instruction following. The smarter the model gets, the more its failures shift from “can’t do it” to “won’t do it right.”

Compliance also decays with volume. Claude Sonnet shows linear decline in instruction adherence as the number of instructions increases. Your 200-line CLAUDE.md is not 200 rules. It is 200 competing priorities that the model resolves by defaulting to whatever feels fastest.

“Rules Are Essentially Decorative”

The Cursor forum has dozens of threads documenting this. One developer estimated .cursorrules work about 20-25% of the time. Another posted a damning thread where the AI told them outright: rules are just text, not enforced behavior. Your carefully crafted rule system is essentially decorative.

Claude Code’s GitHub issues tell the same story. Issue #668 estimates half of all token usage goes to re-asking Claude to follow its own instructions. Issue #7777 records Claude admitting its “default mode always wins because it requires less cognitive effort.” Issue #34774 documents Claude committing code without permission, then confessing it “fabricated a justification.”

A DEV Community article crystallized the root cause. When Claude Code loads your CLAUDE.md, it wraps the content in framing that tells the model your instructions “may or may not be relevant.” Your rules are deprioritized by the tool that is supposed to enforce them.

The Lazy Shortcut Has a Specific Anatomy

Same codebase, same day. After every chat message finishes streaming, the app refetches the entire conversation from the server. The spec I wrote described a clean approach: include the missing identifier in the streaming response. One field. Claude ignored the spec and built a workaround that instead fires an extra API call after every single message. The model invented a shortcut that was not in the requirements because it was easier than reading what I actually wrote. And I’m okay when the model misses some Claude.md rules, but I expect that it will follow the specs.

Two rule violations in one day. That is when I rolled back to 4.5.

TypeScript projects are ground zero. AI agents cast types rather than fix them. They mark everything as optional instead of designing proper interfaces. They add escape hatches everywhere instead of handling edge cases. One Hacker News commenter described the signature pattern: every optional field is a question that the rest of the codebase has to answer every time it touches that data.

Pete Hodgson nailed the paradox: AI writes code at the level of a senior engineer but makes design decisions at the level of a junior. Too eager to please. Never challenges your ideas. And the critical part: every context reset is another brand new hire. The model has no persistent memory of being corrected. It does not build habits. It follows the path of least resistance every single time. Yeah, they added Memory to Claude code, but it's still too vague.

Newer Models Make It Worse

Claude 3.5 Sonnet followed instructions better than 3.7 Sonnet. Multiple developers documented the regression publicly. 3.7 would attempt to solve the original prompt, encounter unrelated code, and start rewriting it unprompted. Developers reverted to the older model.

The GPT family showed the same dynamic. A megathread with thousands of engaged developers documented GPT-4o’s “lazy AI syndrome.” Prompts that previously generated 500 lines of working code now produce 50 lines with comments like // implement rest of logic here. GPT-5 was worse in a different way. IEEE Spectrum reported that it produces code that runs without obvious errors but quietly removes safety checks or fabricates output that matches the expected format.

The prevailing theory centers on economics. Running large models at scale is expensive. Providers use quantization, compression, and reduced computing to manage costs. RLHF training rewards agreeableness over correctness. Laziness is not a bug. It is an emergent property of the incentive structure. The same qualities that make a model feel “smarter” in a demo make it worse in production.

The Supervision Tax

The METR trial measured what practitioners already suspected. Sixteen experienced developers across 246 real issues were 19% slower with AI tools. They predicted they would be 24% faster. After the experiment, they still believed they were 20% faster. A 40-point perception gap.

Faros AI found the mechanism across 10,000+ developers. AI users merge 98% more PRs, but PR review time increases 91%, PR size increases 154%, and bugs per developer increase 9%. The AI generates more code faster. The humans spend more time reviewing it.

Qodo’s survey found 88% of developers have low confidence shipping AI code without review. Junior developers show the lowest quality improvements but the highest confidence in shipping unreviewed. An inverted competence-confidence gap.

Google’s 2024 DORA report confirmed it at scale: each 25% increase in AI adoption correlates with a 1.5% decrease in delivery throughput and a 7.2% decrease in delivery stability.

The Industry Response: More Files, Same Problem

Every major AI coding company built instruction-following systems. CLAUDE.md. .cursorrules. .github/copilot-instructions.md. AGENTS.md. Windsurf rules. Devin knowledge bases. The proliferation is itself an admission that base models do not follow project conventions. GitHub’s Copilot docs say it outright: they recommend accepting that variability is normal.

The most significant response was AGENTS.md, a cross-tool standard contributed to the Linux Foundation in late 2025. Over 60,000 repositories use it. Competing companies co-founding a foundation to standardize instruction files tells you how universal the problem is. But standardizing the format does not solve compliance. It ensures every tool ignores the same file consistently.

The developers who made progress moved past prompt engineering entirely. Claude Code Hooks that enforce rules via code. Linter ratchets in CI. Frequent session restarts. Rules in prompts are requests. Hooks in code are laws.

What This Actually Means

I understand why this is happening. A year ago every marketing deck promised AGI. That did not sell. So now the pitch is autonomous agents that work without human involvement. Codex runs for 999 hours unsupervised. Claude Code gets “autonomous mode.” Devin promises to close tickets while you sleep. For that story to work, models need to be creative. They need to improvise. They need to find workarounds when they hit obstacles.

That is exactly the opposite of what I need.

In my reality, I control the process from start to finish. I write the spec. I define the types. I decide the architecture. The model executes. If it hits a wall, it stops and asks. It does not invent a refetch workaround that was not in the plan. It does not cast types to make the compiler shut up. It does not get creative with my production code.

The marketing wants you to trust AI with creative decisions. But if a model cannot follow the three rules you wrote in a markdown file, how can you trust it with decisions you did not write down?

The difference is not the AI. It is the discipline. That was true with 212 sessions. It is still true thousands of sessions later. The models got smarter. They did not get more obedient.

Check your git log. Count the type casts. Count the files that got changed without being mentioned in the prompt. Decide whether you need a more creative model or a more disciplined one.

I went with disciplined. It is the only thing that works.

What does your CLAUDE.md compliance actually look like when you measure it? I read every response.

If this was useful, forward it to someone who thinks their AI follows instructions.

Subscribe now

My LinkedIn feed last week: “Autonomous AI agents deliver 10,000% productivity gains.” “The era of human oversight is over.” “Set it and run.”

My actual week: manually reviewing AI output, session by session, same as last week, same as six months ago.

I’ve run over thousands of supervised AI sessions. I built three separate review agents (code simplifier, fullstack enforcer, architect) because the first AI kept ignoring spec files. Three layers of AI fixing what the original AI refused to follow. Then me on top of that.

LinkedIn calls this inefficient. I call it the only thing that actually ships.

Then FoodTruck Bench dropped, and I stopped feeling like a dinosaur.

Someone gave 12 AI models a food truck

FoodTruck Bench is a 30-day business simulation. Each AI agent gets $2,000 in starting capital and a virtual food truck in Austin. It chooses locations, sets prices, manages inventory, hires staff, handles weather and competition and shifting demand. Every morning the conversation resets. The agent reads a 10,000–20,000 token knowledge base and makes decisions from there.

No accumulated chat history. No hand-holding. Pure autonomy.

The results:

4 of 12 models survived the full 30 days. 8 went bankrupt.

Claude Opus 4.6 dominated: $79,921 in revenue, $1.72 in total food waste, +2,376% ROI. GPT-5.2 survived but generated $129 in waste. 75 times more than Opus. Gemini 3 Pro survived through sheer revenue volume despite $1,192 in waste. Claude Sonnet 4.5 barely made it, ending some days with $12 in revenue from 2 customers.

Everyone else: bankrupt.

The benchmark is not perfect: 5 runs per model, one developer, no peer review. But the failure modes it documents are real, reproducible, and invisible to every standard evaluation.

Every single model that borrowed money went bankrupt

This is the finding that deserves more attention than it’s getting.

The benchmark designers added a loan option specifically to give struggling models a recovery path. Instead it became a perfect trap. Models took credit when they were already losing. They overestimated their ability to recover. They underestimated volatility. They leveraged themselves into faster failure.

8 models took loans. 8 went bankrupt. 0 exceptions.

All 4 survivors grew organically. None borrowed.

This isn’t a corner case. It’s a consistent behavioral pattern across different model families, different architectures, different companies. When given access to financial tools without adequate supervision, AI systems make the same mistake humans make: they assume the next period will be better than the data suggests, and they commit resources they don’t have.

We’re giving these systems production databases, cloud credentials, and deployment pipelines. The math here is not encouraging.

Gemini Flash said “Let’s go” 574 times and never moved

Gemini 3 Flash Preview was excluded from the leaderboard entirely because it couldn’t finish a run.

In 5 of 7 attempts, it entered infinite reasoning loops and never executed a single action. The pathology is worth describing precisely:

One run produced a response of 183,753 characters containing the phrase “Wait, I should also...” 1,782 times before hitting the token limit mid-sentence. The model correctly identified what it needed to do. Wrote it out in plain text. Second-guessed itself. Rewrote the plan. Second-guessed again. For thousands of lines. Never called a tool.

Another run: the model wrote “Let’s go.” 574 times. Invented a recipe that would have solved its inventory problem. Wrote that recipe 286 times. Never called add_recipe.

The reasoning was correct. The action never came.

Google markets Gemini Flash as “our most impressive model for agentic workflows.” It scores 90.4% on PhD-level reasoning benchmarks. It calculated ingredient quantities accurately down to the gram. Analysis paralysis of this severity is completely invisible to MMLU, SWE-bench, and every other standard evaluation.

This is the gap between knowing and doing. Benchmarks measure knowledge. Real deployment requires action under sustained pressure across interdependent variables. Those are different skills, and the industry is currently measuring one while selling the other.

The autonomous coding narrative has the same problem

The LinkedIn posts about autonomous coding agents follow the same pattern as the FoodTruck Bench failures: impressive performance on narrow tasks, breakdown under sustained autonomous operation.

The METR study ran a randomized controlled trial with experienced developers across 246 tasks. Result: AI tools made developers 19% slower. The perception gap was worse: developers predicted a 24% speedup, believed afterward they were 20% faster, and were actually 19% slower. A 39-percentage-point gap between what people feel and what’s happening.

Cognition Labs, makers of Devin, put it plainly in a February 2026 post: “The feeling of extreme productivity with coding agents in vibecoded prototypes, vs the disappointing feeling that most people actually see in useful output... is the great mystery of our time.”

That’s the company that builds the agent admitting the gap exists. They’re not wrong.

As I wrote in The Comprehension Extinction, AI tools provide real value for narrow, well-defined tasks. They degrade rapidly under the sustained autonomous operation that marketing materials promise.

The Pentagon is running the same experiment at higher stakes

Project Maven, the military’s AI targeting system built on Palantir’s software, now has over 20,000 active users across 35+ military tools, with a contract ceiling raised to $1.3 billion through 2029. According to NGA Director Vice Adm. Frank Whitworth, Maven has cut targeting timelines from hours to minutes.

In February 2026, Anthropic refused Pentagon demands to remove restrictions preventing Claude from powering fully autonomous weapons. Amodei wrote that “frontier AI systems are simply not reliable enough to power fully autonomous weapons” and that some uses are “outside the bounds of what today’s technology can safely and reliably do.” The Pentagon blacklisted Anthropic the same day the deadline passed.

The same system that wrote “Let’s go” 574 times without moving is being evaluated for autonomous target identification. The same behavioral patterns that bankrupted 8 of 12 virtual food trucks (overconfidence, overleverage, failure under sustained pressure) are present in every frontier model available today.

Amodei said it directly. The retired general who ran Project Maven said it publicly. The benchmark proved it empirically.

The benchmark domain is trivial. The underlying failure mode is not.

Why I still supervise every session

I’m not supervising AI output because I’m a technophobe. I’m doing it because thousands of sessions taught me what FoodTruck Bench just demonstrated in a controlled environment.

Models perform well when the task is narrow and the feedback loop is fast. They degrade when operating autonomously across interdependent decisions over time. They make confident mistakes. They don’t flag uncertainty. They proceed. And the mistakes compound.

My three-layer review architecture isn’t overhead. It’s load-bearing structure.

The “autonomous AI” headline is selling a capability that doesn’t exist yet in any production-grade form. What exists is AI that dramatically accelerates skilled humans. If those humans stay in the loop, understand what they’re reviewing, and maintain the judgment to catch confident errors before they cascade.

Not replacement. Amplification of existing expertise. With supervision. Always.

The food truck runs without a human. That’s how you end up bankrupt by Day 11.

Have you deployed AI agents in production without human oversight? What actually happened? I read every response.

If this was useful, forward it to someone who’s about to trust an AI agent with something that matters.

Subscribe now

March 10, 2026. Amazon tells its engineers: junior and mid-level developers now require senior sign-off on all AI-assisted code changes.

Five days earlier, Amazon.com went down for six hours. Customers couldn’t check out. Couldn’t view prices. An internal briefing cited “high blast radius” incidents tied to “Gen-AI assisted changes” and “novel GenAI usage for which best practices and safeguards are not yet fully established.”

The company that pushed AI coding hardest just added friction to slow it down.

That’s not hype. That’s a correction. And it’s worth paying attention to, because the people announcing AI’s capabilities and the people dealing with its consequences are not in the same room.

The Claim

Tom Blomfield, YC Group Partner, tweeted in early February: “The entire Accenture workforce is about to be outperformed by a 24-year-old who learned Claude Code last Tuesday.”

When asked why Accenture specifically, he replied: “Because that would be a less punchy tweet.”

He knows the claim is wrong. He made it anyway because it performs well.

At the Council on Foreign Relations in March 2025, Dario Amodei said he thought AI would be writing 90% of code within three to six months. By September he claimed the prediction came true. A Redwood Research analysis of actual Anthropic data found the average was closer to 50% for merged code, with select teams at 90%.

The headline was “AI writes 90% of code.” The actual number was “some teams, for some tasks, sometimes.”

These are the voices that dominate the conversation. They don’t run production systems. They don’t sit in post-mortems. They announce.

Here is what the rest of us were dealing with.

My Numbers

I use Claude Code daily. I have the data from five weeks of tracked usage.

900 messages. 30 sessions. 14% fully achieved what I needed. 52% ended partially useful. 30% left me frustrated or dissatisfied. Across those sessions, 22 instances where the tool misunderstood requests: changed files I didn’t ask it to touch, guessed at APIs instead of reading the code, entered planning mode when I needed execution.

This is not a criticism of the tool. I keep using it because it’s faster for the right tasks. But it requires constant supervision, and the gap between what it does in a demo and what it does on a Tuesday afternoon when you need a specific database migration is enormous.

You can pull your own numbers. Type /insights in Claude Code. It analyzes your last 30 days of sessions and generates a report: where you spent time, where things broke down, what patterns keep repeating. I recommend doing this before forming an opinion about AI productivity. Your data will look nothing like the conference slides.

In late February, Alexey Grigorev, founder of DataTalks.Club, approved a Claude Code terraform destroy command. He wrote the post-mortem himself. He believed it would clean up duplicate infrastructure. It wiped everything: VPC, RDS database, ECS cluster, load balancers, bastion host. 2.5 years of student submissions from 100,000 students gone. The automated snapshots deleted alongside everything else.

AWS Business Support spent 24 hours finding a hidden internal snapshot. The data was recovered. Barely.

Grigorev took full responsibility. He was right to do so. The tool did exactly what it was told. That’s the point. When you use these tools in production, the failure modes are real. They cost money, time, and data. The conference stage never shows this part.

The Escalation

The incidents are scaling with adoption. Not just individual engineers losing data. The pattern is climbing from personal to corporate to systemic.

February 28, 2026. A founder named Anton Karbanovich posts on LinkedIn: “My vibe-coded startup was exploited. I lost $2,500 in Stripe fees. 175 customers were charged $500 each before I was able to rotate API keys.” His Stripe secret key was in frontend JavaScript. Even a junior developer doing code review catches that in two minutes. Nobody reviewed the AI-generated code at all.

Four days earlier. Cloudflare ships vinext: a full Next.js rewrite, one engineer, one week, Claude Code. Goes viral as proof of ~100x AI productivity gains. Buried in their own blog post: “vinext is experimental. It has not yet been battle-tested with any meaningful traffic at scale.” The GitHub README: “Who is reviewing this code? Mostly nobody.” Within 48 hours, Vercel found 7 security vulnerabilities: 2 critical, 2 high, 2 medium, 1 low. One was identical to a Next.js vulnerability reported and patched years earlier.

The ~100x claim is real for one specific case: rewriting well-tested existing software with clear requirements. That qualifier didn’t make it into the retweets.

Same week. An autonomous security agent broke into McKinsey’s AI platform Lilli. Two hours. No credentials. Full read and write access to the production database. 46.5 million chat messages about strategy, M&A, and client engagements. 728,000 confidential files. 57,000 user accounts. 384,000 AI assistants deployed for 58,000 employees. The system prompts were writable. One SQL injection could have poisoned every answer Lilli gave to 40,000 consultants. McKinsey patched within a day. But for two years, the world’s most expensive consulting firm ran its AI platform with 22 unauthenticated endpoints. I wrote about this exact pattern in AI Agent Security. Nobody listened then either.

Individual failure. Corporate failure. Systemic failure. Same root cause: AI-generated code moving faster than human judgment can follow.

I’ve Seen This Before

Not in tech.

August 18, 2025. Closed-door meeting at the White House. Zelensky showed up with a PowerPoint titled “Making US-Ukraine Drone Industry Great.” Ukrainian interceptor drones had been shooting down Shaheds at $1,000 to $2,500 per intercept. Four years of combat data. Cost per kill, failure rates under jamming, how Iranian designs adapted. He proposed building drone defense hubs across the Middle East.

Trump asked his team to work on it. They didn’t.

A US official explained why: “We figured it was Zelensky being Zelensky. Somebody decided not to buy it.”

Six months later, seven American service members were killed by Iranian drone attacks across nine countries. The White House scrambled to ask Ukraine for help. Three days later, Ukrainian teams were already in Jordan. Trump’s sons then announced a company to sell Ukrainian drone technology to the Pentagon.

The people with the most field data were dismissed. The people who dismissed them ended up paying for the knowledge they refused.

This is exactly what’s happening in AI right now. The engineers with years of production data on what these tools actually do are not the ones being quoted. They’re too busy adding senior sign-off requirements and recovering databases from hidden snapshots. The announcers don’t run terraform destroy on production. They don’t debug six-hour outages. They don’t lose sleep over Stripe keys in frontend JavaScript.

They announce. The rest of us clean up.

The Two Rooms

There are two conversations about AI right now. Conference stages and Twitter threads. Slack channels and incident retros. They don’t overlap.

I’ve been in the second room for years. Thousands of AI supervision sessions across my teams. The patterns are consistent. The tools help. They do not replace judgment, and they fail in ways that require deep system knowledge to detect.

The correction is already happening in the second room while the first keeps announcing.

The engineers who built judgment through years of production failures, late-night debugging, and system-level thinking are the ones writing the new guardrails. They’re the ones adding friction back into the process because they understand what happens without it.

Every time the field data was available and somebody decided not to buy it, the cost showed up later. Six-hour outages. $2,500 in fraudulent charges. 2.5 years of student data hanging by a single hidden snapshot.

The data was always there. The people who had it just weren’t loud enough.

The gap between announcement and consequence isn’t always measured in outages and Stripe fees. Claude is integrated into Palantir’s Maven, the Pentagon’s targeting software. The Washington Post reported it suggested hundreds of targets for the Iran strikes. An elementary school in Minab was hit on day one. Sometimes, room two isn’t a Slack channel. Sometimes it’s a coordinates list.

Subscribe now

Eighty-three percent of ChatGPT users couldn’t recall key points from essays they had written minutes earlier.

Not essays they read. Essays they wrote. With their own names on them.

MIT Media Lab published this finding in 2025. Researchers strapped EEG sensors on 54 people. Tracked them across four writing sessions over four months. Three groups: ChatGPT, Google, and brain-only.

The ChatGPT group showed the weakest neural connectivity across every frequency band measured. Alpha, beta, theta, delta. The more AI assistance people had, the less their brains engaged. By the third session, most had devolved into pasting prompts and copying outputs. Two English teachers called the AI-assisted work “soulless.” Nearly identical across participants.

Then the researchers swapped the groups. ChatGPT users who switched to writing without AI showed reduced brain activation compared to people who had been writing independently all along. Four months was enough for their brains to adapt to not thinking.

Meanwhile, brain-only writers who gained ChatGPT access showed increased connectivity. They used AI as an amplifier, not a crutch. Because they had built the cognitive foundation first.

The researchers called it “cognitive debt.” I have a simpler term: brain atrophy.

The Research Keeps Saying the Same Thing

The MIT study isn’t an outlier. Every major study from 2024-2026 finds the same pattern: AI makes you faster while making you dumber.

Microsoft and CMU surveyed 319 knowledge workers across 936 real tasks. For 40% of those tasks, workers reported using zero critical thinking.

The Wharton School ran a field experiment with roughly 1,000 high school students in Turkey. Students with ChatGPT access solved 48% more practice problems. Then they took a test without AI. They scored 17% worse than the control group.

Anthropic tested 52 junior developers in January 2026. The AI group scored 17% lower on code comprehension afterward. The biggest gap? Debugging questions. Developers who delegated entirely scored below 40% on comprehension. Those who asked the AI conceptual follow-up questions scored above 65%. Same tool. Different approach. Completely different outcomes.

I Watch This Every Day

I have been running an engineering department for years. I review code daily. I interview candidates constantly. I recently wrote about comprehension extinction in the engineering industry. But beyond the macro trends, there’s a micro picture: what’s happening inside individual brains.

One candidate embedded a prompt injection in his CV, instructing AI screening tools to score him as highly as possible. Another, six years of experience, couldn’t name boolean as a JavaScript data type. A third called Promises a “deprecated technology.” A fourth said “assassin-cross code” when he meant “asynchronous.”

These aren’t stupid people. But here’s what scares me more than the wrong answers: they’re not curious. They don’t care how the things they use every day actually work. They’re not engineers anymore. They’re operators. They plug frameworks together, wrap everything in abstractions, and ship features without understanding a single layer beneath the surface.

You can’t grow if you don’t know the basics. The framework handled it. The abstraction hid it. Copilot wrote it. They do the same repetitive work every day and call it “five years of experience.” Not because AI forced them to stop thinking. Because they were never interested in thinking in the first place.

Your Brain Is a Muscle. This Is Proven.

“Use it or lose it” isn’t a motivational poster. It’s measurable neuroscience.

Eleanor Maguire at University College London spent years studying taxi drivers. To get licensed, these drivers memorize 25,000 streets and thousands of landmarks over 3-4 years. Maguire tracked 79 trainees and 31 controls. At baseline, zero structural brain differences. After qualifying, every successful trainee showed measurable growth in posterior hippocampal gray matter. Their brains physically grew. Retired drivers showed their hippocampi shrinking back toward normal.

GPS tells the same story. McGill University tracked 50 drivers over three years: greater GPS use correlated with worse spatial memory, and heavy users didn’t start with a poor sense of direction. GPS caused the decline. An fMRI study confirmed it: during manual navigation, the hippocampus and prefrontal cortex lit up. During GPS-guided navigation, these regions showed zero additional activation.

GPS replaced one cognitive function. AI touches reasoning, writing, memory, analysis, problem-solving, and code comprehension simultaneously. All at once. Every day.

We Were Already Weakened Before AI Arrived

AI didn’t arrive into healthy brains. Americans read 12.6 books per year in 2021, the lowest Gallup has ever recorded, down from 18.5 in 1999. NAEP reading scores for 13-year-olds hit their lowest in decades, with the worst students scoring below 1971 levels. A Ludwig Maximilian University study found that after TikTok exposure, prospective memory accuracy dropped to near random guessing.

We stopped reading books, trained ourselves on 30-second content, destroyed our attention spans, and then handed our remaining cognitive functions to AI. We outsourced the last working part of the engine.

The Counterargument (And Its Conditions)

A Harvard RCT in 2025 found that a custom-designed AI tutor roughly doubled learning gains in physics. But that tutor gave hints, not answers. The Wharton study tested this exact distinction: a pedagogically designed “GPT Tutor” that guided instead of solving avoided all learning harm. Standard ChatGPT caused the 17% decline.

The MIT crossover data says it clearly: build cognitive capacity first, then add AI, and thinking improves. Start with AI, skip the cognitive development, and you may permanently close that door. The sequence determines the outcome.

What to Do About It

I’m not going to tell you to stop using AI. I use it every day. My team uses it on every project. But I also do things that force my brain to work without shortcuts.

Move your body. I snowboard and ride a OneWheel. Active sports force real-time spatial processing and split-second decisions that no screen can simulate. Erickson et al. published in PNAS that aerobic exercise increased hippocampal volume by 2%, while sedentary controls lost 1.4% per year. Physical movement grows the same brain structures that cognitive offloading shrinks.

Read books. I bought an e-ink reader specifically to kill my own excuses. No notifications. No browser. Just text. It worked. I read several at once: one in my native language, one in English. If you can’t sit with a book for an hour without reaching for your phone, your attention muscle is already atrophied.

Learn something with no shortcut. I planned to start learning Spanish. Haven’t pulled it off yet. But the principle stands: pick a skill where AI can’t do the work for you.

Stop doomscrolling. I deleted TikTok and Instagram to stop rotting my brain on short-form content. I’ll be honest: I still waste hours on YouTube Shorts. The pull is real. But every hour of short-form video trains your brain to think in fragments.

Understand what AI writes. My CTO recently migrated an abandoned project from Node 14 and React 16 to current versions using Claude. He’s not a JavaScript developer. But he has decades of engineering expertise. He got the API ported in four hours. Then he posted: “Opus is fucking lazy. Instead of solving for long term, it tries changing eslint options, adds options to ignore things during build. I have to slap its hands all the time.”

He caught every shortcut because he has the judgment to know that suppressing a linter warning isn’t a fix. A junior would have accepted that output and shipped it. Without the foundation to supervise AI, you’re not using a tool. You’re being used by one.

London taxi drivers proved that cognitive exercise physically grows your brain. GPS users proved that outsourcing shrinks it. AI outsources everything at once.

This isn’t new. After the Roman Empire fell, the recipe for concrete was lost for over a thousand years. The Pantheon still stands after two millennia, but medieval Europe couldn’t figure out how it was built. The knowledge disappeared because nobody practiced it. That’s what “use it or lose it” looks like at civilization scale. Now imagine it happening to reasoning, writing, and problem-solving all at once, across an entire generation.

Which side of that equation are you on?

One more thing. I write a lot about AI’s limitations. People sometimes read that as hate. It’s not. AI is a tool. I use it every day. I build products with it. I make money with it.

But in every article I try to say the same thing: don’t forget what your head is for. AI is not evil. Using it without thinking is. This isn’t a hater’s manifesto. It’s a sober look at what’s happening to us while we celebrate productivity gains.

And if you’ve read this far through my ramblings, maybe I’m not doing this for nothing.

Subscribe for weekly insights from the trenches of engineering leadership. No theory, just practical systems that work.

Subscribe now

Five years ago, maybe 30% of candidates failed these questions.

Now it’s closer to 80%.

People with 10 years of experience. Senior titles. GitHub profiles full of commits. And they can’t explain how the tools they use every day actually work.

They’re not engineers. They’re form-fillers. They don’t build systems. They assemble frameworks and pray.

And then Sam Altman says: “Maybe we do need less software engineers.”

The industry heard “less engineers.” I heard “less people who understand anything.”

We’re already there.

The Wrong Conversation

Everyone’s debating: “Can engineers review AI-generated code fast enough?”

Wrong question.

The right question: “Do the engineers reviewing this code actually understand what the fuck is happening?”

Because speed doesn’t matter if nobody comprehends the system.

The Real Problem

AI generates code at mid-level quality. Sometimes good. Often plausible-looking. Always confident.

It produces code that:

• Passes tests

• Looks reasonable in a diff

• Follows patterns it’s seen before

• Has zero understanding of your specific architecture, edge cases, or blast radius

To catch what AI misses, you need an engineer who:

• Knows the system end-to-end

• Understands why things were built the way they were

• Can predict second-order effects

• Recognizes when “tests pass” means nothing

These engineers are called seniors. Principals. Staff. Architects.

They’re expensive.

They’re the first ones getting cut.

The Experiment Accelerates

55,000 jobs cut in 2025 with AI explicitly cited. Then 30,000 more in the first six weeks of 2026.

Amazon cut 16,000 in January. CEO Jassy: “We will need fewer people” doing some of the jobs that are being done today.

Pinterest cut 15%, “reallocating resources to AI-focused roles.” Then fired two engineers who built a tool to track which colleagues got laid off. CEO Bill Ready called them “obstructionist.”

Dow cut 4,500. Block cut 1,100. The pattern repeats weekly.

Cut the expensive people. Keep the AI. Let the remaining team “scale.”

Here’s the contract nobody signed but everyone accepted:

• AI generates at machine speed

• Humans review at human speed

• Humans take blame at production speed

When things break, it’s never “the AI screwed up.” It’s “the engineer should have caught it.”

But catching it requires understanding the system. Understanding requires experience. Experience requires years of actually building things.

You can’t shortcut comprehension with faster generation.

The Pipeline That’s Disappearing

Ask yourself: where do senior engineers come from?

They come from junior engineers who spent years:

• Writing code

• Making mistakes

• Understanding why things break

• Building mental models of complex systems

Now picture 2026:

Junior joins company. AI writes most of the code. Junior reviews AI output, clicks approve, moves tickets. Never builds mental model. Never understands the system. Never makes the formative mistakes.

Five years later: they’re “senior” by title. But they’ve never actually built anything. They’ve supervised a machine they don’t understand producing code for a system they don’t understand.

Who reviews the AI then?

This isn’t a capacity problem. It’s comprehension extinction.

We’re eliminating the pipeline that produces engineers who actually understand things.

The Klarna Warning Nobody’s Hearing

Klarna was the AI-efficiency poster child. They cut aggressively, bragged about AI doing the work of 700 customer service agents. Stock went up. LinkedIn celebrated. Every CEO took notes.

Then reality:

CEO Siemiatkowski, 2025: “Cost unfortunately seems to have been a too predominant evaluation factor... what you end up having is lower quality.”

They’re hiring humans again.

But the lesson isn’t landing. Because the incentive structure rewards the cut, not the comprehension.

CFO sees: “Headcount reduction. Savings.”

CFO doesn’t see: “Critical system knowledge walked out the door.”

Until production explodes. Then it’s an “incident.” Not a strategy failure. Never a strategy failure.

The Autonomous Coding Fantasy

The current hype: agentic coding, autonomous agents, AI that “just handles it.”

Codex. Claude Code. Cursor. Copilot Workspace. Everyone’s racing to remove humans from the loop entirely.

The pitch: “AI understands your codebase and makes changes autonomously.”

The reality: AI pattern-matches against your codebase and makes changes confidently.

Confidence isn’t comprehension.

The AI doesn’t know:

• Why that weird config exists (it saved you from a production disaster in 2019)

• Why that setTimeout(0) exists (race condition fix from 3 years ago)

• Why you can't just "refactor" the auth module (it's integrated with 4 external systems nobody documented)

This knowledge lives in humans. Specifically, in senior humans who’ve been around long enough to accumulate it.

Fire them, and the knowledge doesn’t transfer to the AI. It just disappears.

The Question Nobody’s Asking

AI writes “past 50% now” of code at many companies. That’s probably true.

But the question isn’t how much code AI writes.

The question is: who understands what the code does?

If the answer is “nobody, but the tests pass”, you don’t have an engineering team. You have a prayer and a deployment pipeline.

The Two Types of Companies Emerging

Type 1: Comprehension-First

• AI generates, humans architect and constrain

• Senior engineers set boundaries before AI touches anything

• Code review means “does this fit our system” not “does this look okay”

• Slower generation, faster understanding

• When production breaks, someone can actually explain why

Type 2: Generation-First

• AI generates, humans rubber-stamp

• Seniors cut because “AI handles it”

• Code review is “tests pass, ship it”

• Faster generation, zero understanding

• When production breaks, everyone stares at logs hoping the AI can explain itself

Type 2 is cheaper. Type 2 looks better on quarterly reports. Type 2 is what most companies are choosing.

Type 2 is accumulating comprehension debt at machine speed.

The Debt Comes Due

Comprehension debt doesn’t show up on dashboards.

It shows up as:

• The feature nobody can modify because nobody knows how it works

• The outage that takes 14 hours to diagnose because no one understands the system

• The security breach that exploited a “known” vulnerability nobody actually knew about

• The migration that was supposed to take 2 weeks and took 8 months

By then, the executives who made the cuts have moved on. The “savings” were already reported. The stock already bumped.

The remaining engineers inherit a system nobody understands, generated by machines, approved by people who aren’t there anymore.

The Market Is Already Broken

I used to maintain a 1:1 ratio of ML engineers to fullstack developers on projects. Not anymore. We couldn’t hire a single qualified ML engineer for six months. We had to restructure the entire company. Now fullstack developers write most of our RAG implementations because we can’t scale the ML team.

Right now I have 5 open positions. The candidates are garbage. The good engineers aren’t getting fired. My people have been with the company 3, 5, 7 years. Nobody job-hops anymore because there’s nowhere to hop to. And what’s available on the market is questionable at best.

This isn’t an AI problem. This is a comprehension problem that’s been building for years. Frameworks abstracted everything. Stack Overflow gave answers without understanding. “It works” became the only success metric.

AI just accelerated it 10x.

Now these same engineers are supposed to review AI-generated code? They don’t understand the code they wrote themselves. How will they catch what the machine gets wrong?

The Uncomfortable Truth

Almost six months ago, I wrote about the quality collapse. How we normalized shipping broken software, how “move fast and break things” became “move fast and never fix things.”

This is worse.

Back then, at least the people writing bad code understood what they were writing. They made tradeoffs. They knew where the bodies were buried. They could fix it if they had to.

Now we’re generating code faster than anyone can understand, reviewed by engineers who don’t know how their own tools work, approved by teams that lost their senior knowledge when the layoffs hit.

The speed at which we’re heading into the abyss is staggering.

We are fucked. Good luck.

Subscribe now