When Did We Become Okay With Garbage Software?

We have more software being shipped right now than at any other point in history. The AI slop machine is running 24/7 in every company you have heard of and every company you have not. And for some reason, all of it is riddled with bugs. Incredible bugs. Bugs that take down billing. Bugs that revert merged code. Bugs that lock you out of the platform you built your entire business on top of.

And the new phrase making the rounds, the one I have started hearing in standups and on Twitter and in postmortems, is this: “regressions will happen, it’s acceptable.”

No. It is not.

”Acceptable” Is a New Word in This Conversation

I want to be very clear about something. The phrase “regressions are acceptable” — at the current rate, at the current severity — is brand new to this industry. That is not how engineering teams talked five years ago. That is not how they talked two years ago. It showed up with the solo vibe coders, made its way into the language of indie founders, and now it is creeping into real engineering orgs where people should know better.

Regressions in business-critical paths used to be a fireable offense. Now it is a shrug and a Linear ticket. That is a culture shift, and it is the wrong one.

This is not me being cranky for the sake of it. The engineering team at my company talks about this almost every single week. The other founders we talk to are talking about it. Every group chat I am in with people who run engineering at startups is talking about it. Anyone who ships software to a paying customer in 2026 is having this exact conversation, in some form, right now.

Three Incidents in Two Weeks

Let me just list what has happened in the last two weeks. Not in the last year. The last two weeks.

GitHub merge queue, April 23rd. PRs merged via the merge queue with squash merge produced incorrect merge commits when the merge group had more than one PR in it. Changes from previously merged PRs were inadvertently reverted by subsequent merges. 230 repositories affected. 2,092 PRs. The root cause was that a feature flag gate was incomplete — a code path that was supposed to be gated was not. So GitHub itself, the platform that hosts essentially all of the world’s source code, shipped a regression that silently un-merged people’s work for almost five hours.

Anthropic’s HERMES.md billing bug. The mere presence of the case-sensitive string HERMES.md in a git repo’s recent commit history triggered a server-side billing redirect. Your API requests would silently get rerouted from your Max plan quota to “extra usage” billing. You got misleading errors. You got charged. Support initially refused refunds and only backtracked after the story went viral. A string in your commit history. That is what was deciding how you got billed.

AWS ECR cleanup jobs. I do not have a clean public writeup on this one, so take it with the appropriate grain of salt — but enough people in my network got hit by the same pattern in the same window that I am comfortable mentioning it. The story I am hearing is that cleanup jobs broke in one region, images that should have been deleted were not, and a bunch of customers got surprise bills for storage they had explicitly configured to be cleaned up. They wrote support. Support did not respond, did not explain, just deleted the old images quietly and acted like nothing ever happened.

These are real events. They have real, serious, money-on-the-line consequences. And they all happened in the same two-week window.

This Used to Be a Once-a-Year Conversation

Incidents at this level used to happen maybe once a year per company. And when they did, it was a big deal. Engineers stayed up. Postmortems were public and detailed. People got reorganized. A major incident was the kind of thing that defined a quarter for the entire org.

Right now? Three of these from three of the largest infrastructure providers on Earth, in two weeks, and the dominant reaction is “yeah, regressions happen.” That is not a coping mechanism. That is permission. We are giving everyone permission to ship worse, and they are taking it.

Code Production Is Outrunning Review

Here is the mechanic underneath all of this, and it is not complicated.

Code is being produced way faster than review and QA can keep up with. There is no version of the current setup where they can keep up. PRs per author are up roughly 20% year over year. Incidents per PR are up 23.5%. Change failure rates are up about 30%. AI-generated code creates 1.7x more issues than human code, with 1.4x more critical issues per PR. 43% of AI-generated code changes need manual debugging in production even after passing QA and staging. Those are not numbers I am making up. Those are from the reports companies are publishing right now.

So here is what actually happens. The AI writes the code. A human pretends to review the code. The code gets merged. The code breaks something. Nobody can really say who is responsible, because, honestly — bro, nobody read that 10,000 line PR. The AI wrote it, the AI agreed it looked good, and the merge button got clicked. Who is on the hook when that thing takes down billing for half a day?

This is the part where the “regressions are acceptable” framing comes from. It comes from a quiet acknowledgment that nobody is actually accountable anymore. If nobody read the code, nobody can be blamed for the bug. If nobody can be blamed, the bug is just a fact of nature, like weather.

That is not engineering. That is laundering responsibility.

When the Foundation Is Vibe-Coded

Now zoom out one level. You build your company on top of Anthropic’s API. Your customer signs a contract with you. The HERMES.md bug hits. Your app stops working in a way that looks completely random from your customer’s seat. They email you. What are you going to say?

“Sorry, Anthropic was vibe coding”?

You cannot say that. You also cannot really say anything else, because you genuinely do not know why your app is broken until the postmortem lands days later. Your customer does not care. Your customer wanted the thing they paid for to work, and it did not, and the explanation is going to be that a string in a markdown file changed how their requests got billed by a third party two layers below your stack.

Amazon’s March 2026 outages were partly traced to AI-assisted code changes deployed without proper approval. Anthropic had a widespread login outage on March 11th where thousands of people thought they had been banned from Claude. They had another elevated-error event on April 15th. These are the providers everyone else is building on. When the providers ship slop, every downstream company eats it, and the customer at the very end of the chain has nowhere to send the complaint.

This is what happens when “regressions are acceptable” becomes the default culture at the bottom of the stack. It does not stay at the bottom. It compounds upward.

Push Back

I am writing this because I think engineers who care about their craft should be pushing back on the new normal, hard, in their own teams.

When someone in your standup says “regressions will happen, that’s acceptable,” ask which regressions, in which paths, with what blast radius. Ask what the rollback plan was. Ask why the tests did not catch it. Ask whether the PR was actually read by a human who could speak to what was inside it. Make people answer the questions. Make accountability a thing that has to be in the room.

It is completely natural for someone who cares about software to be uncomfortable with where this is going. That instinct is correct. Trust it.

We have spent the last year being told that the new pace is the new pace, that the old standards do not apply, that craftsmanship is a vibe and shipping is the only thing that matters. Three production fires in two weeks at the foundational layer of the entire industry says otherwise. Customers who lost money say otherwise. Engineers who used to take real pride in not breaking things say otherwise.

Garbage software is not acceptable. It never was. It is not now. Stop calling it acceptable.