I just got off the phone with a client who makes boxes.
That’s the whole business. They’re a local company. They make boxes and they ship them. A while back they hired a few people to build their shipping system, and those people vibe coded it. Prompt in, app out, ship it.
And everything worked. The screens were fast. The warehouse employees loved it. Management was thrilled. For eight months, the system ran without a major incident.
Then November arrived.
A large retail customer placed a holiday order for 15,000 boxes, spread across hundreds of shipments. Normally the warehouse processed around 300 orders a day. Suddenly it needed to process 1,200.
Management wasn’t worried. The application had handled everything they’d thrown at it. But nobody had ever tested what happened when hundreds of shipping labels were generated at the same time.
9:00 AM. Everything looks normal. The warehouse team starts working the new orders. Workers scan boxes, select a carrier, and print shipping labels. At first, it all works.
Then the shipping screens start taking 10 to 15 seconds to respond. Some employees click Print Label again, figuring the first click didn’t register. Now they’re getting duplicate labels.
10:30 AM. Things get ugly. The application starts timing out. Some labels print, but their tracking numbers never get saved. Others get attached to the wrong shipments, because multiple background processes are updating the same order records with no concurrency protection. A worker scans a box and the screen shows the previous customer’s shipment.
Supervisors tell everyone to stop using the system.
Noon. The warehouse goes manual. Orders pile up. Workers are handwriting shipping information and typing addresses straight into the UPS and FedEx websites. Nobody can say for sure which orders were processed, which labels printed, or which customers got tracking notifications. Some customers get duplicate tracking emails. Others get nothing.
By the end of the day, hundreds of shipments are delayed. A handful are mislabeled and headed to the wrong destinations. The company has missed its largest customer’s shipping deadline.
Eight months of apparently flawless operation. One unusually busy morning. And the entire shipping operation is on its knees.
The lost revenue is the cheap part. The expensive part happens quietly, in a retailer’s purchasing office, when a supplier misses the holiday deadline. Buyers don’t send angry emails. They just stop returning calls, and next year’s order goes to someone else. And when another company asks that buyer about the box company, all they get back is a slow shake of the head.
This is a local company that makes boxes lol. Boxes. If it can happen here, it’s happening everywhere.
The Table That Only Had Room for One
So I opened it up.
The developers designed the database assuming one order equals one shipment. Here’s roughly what the core table looked like:
Order # | Customer | Boxes | Tracking # | Status
--------+------------+-------+------------+--------
1001 | Retailer A | 50 | 1Z999AA | Shipped
1002 | Retailer B | 25 | 1Z888BB | Shipped
1003 | Retailer C | 75 | 1Z777CC | ShippedFor eight months, that worked beautifully. Every order shipped in one batch, with one tracking number.
Then the holiday order came in. Fifteen thousand boxes don’t go out on one truck. They had to go out in hundreds of separate shipments over several days, each one with its own label and its own tracking number. Say each shipment held around 50 boxes.
See the problem? The table only has room for one tracking number and one shipping status per order. Nobody ever designed it to handle a partial shipment, let alone hundreds of them.
What actually happened. Here’s that one row for the holiday order, after each shipment went out. Everything in bold is a change the system never should have made.
After | Order # | Customer | Boxes | Tracking # | Status
--------------+---------+------------+--------+------------+----------
1st shipment | 1004 | Retailer A | 15,000 | 1Z0001 | Shipped ◀
2nd shipment | 1004 | Retailer A | 15,000 | 1Z0002 ◀ | Shipped
3rd shipment | 1004 | Retailer A | 15,000 | 1Z0003 ◀ | Shipped
… | … | … | … | … | …
Last shipment | 1004 | Retailer A | 15,000 | 1Z0300 ◀ | ShippedThe first shipment goes out, and the system marks the entire 15,000-box order as Shipped. Every shipment after that prints a new label, and every new label overwrites the last tracking number. By the time the final truck pulls away, hundreds of tracking numbers have been written into that one field and erased. Exactly one survives. Customer service pulls up the order and sees only the latest. Nearly all 15,000 boxes have effectively vanished from the system.
And the inventory reports stop matching what’s physically sitting in the warehouse:
After the 1st shipment | What the system says | What's on the warehouse floor
-----------------------+----------------------+----------------------------------------
Boxes shipped | 15,000 | About 50
Boxes still to ship | 0 | 14,950 sitting on pallets
Order status | Shipped | Almost none of it has left the buildingTechnically, the application isn’t crashing. There may not be a single exception in the logs. The database is doing exactly what it was designed to do.
The developers modeled the business wrong.
An experienced engineer would have separated Orders, Shipments, and Shipment Items into distinct entities, so one order could hold many shipments, each with its own tracking number, quantities, and status.
What should have happened. The order keeps track of the big picture:
After | Order # | Customer | Boxes ordered | Boxes shipped | Status
--------------+---------+------------+---------------+---------------+------------------
1st shipment | 1004 | Retailer A | 15,000 | 50 | Partially Shipped
2nd shipment | 1004 | Retailer A | 15,000 | 100 | Partially Shipped
… | … | … | … | … | …
Last shipment | 1004 | Retailer A | 15,000 | 15,000 | ShippedAnd every shipment gets its own row in a separate Shipments table:
Shipment # | Order # | Boxes | Tracking # | Ship date | Status
-----------+---------+-------+------------+-----------+--------------
S-001 | 1004 | 50 | 1Z0001 | Day 1 | Delivered
S-002 | 1004 | 50 | 1Z0002 | Day 1 | Delivered
… | … | … | … | … | …
S-300 | 1004 | 50 | 1Z0300 | Day 5 | Label PrintedNothing gets overwritten. Every tracking number survives. The order only says Shipped when the last box actually leaves, and customer service can see every shipment at a glance. A Shipment Items table would go one level deeper and record exactly which products went into which shipment, but even these two tables alone would have saved the week.
That’s a conversation you have on day one, before a single table exists. I learned the same lesson from the other direction in BenchBoard, when three lineup tables had to become one atomic snapshot. Get the shape of the data wrong and nothing built on top of it can save you.
The AI didn’t necessarily write bad code. It correctly implemented a bad understanding of the business.
That’s a much harder problem to catch than a syntax error or a failing test.
And there is no changelog. None. Not because someone deleted it. Because nobody ever asked the AI to keep one.
Read that again. Nobody asked, so it never existed.
The AI didn’t refuse. It didn’t forget. It just never brought it up, because it doesn’t bring things up. It doesn’t know a shipping company is going to have to split an order someday, or that somebody will eventually need to know why a table looks the way it does. It built exactly what it was asked to build, by people who didn’t know what to ask for.
Seven Problems That Were There on Day One
The data model was the worst of it, but it wasn’t alone. Here’s what else was hiding in that codebase. And here’s the part that should worry you: I didn’t find these only at the box company. I find some version of this list in nearly every vibe-coded codebase that lands on my desk. None of it was obviously broken. All of it worked under the conditions the developers understood.
Synchronous API calls. Every label request sat and waited on the carrier’s API, tying up the server and slowing everything else down
No idempotency. Clicking Print Label twice could create two separate shipments instead of safely handing back the first one
Race conditions. Two workers, or two background tasks, could update the same shipment at the same time with nothing coordinating them
Poor database indexing. Lookups that took milliseconds with 10,000 records got expensive after eight months of shipping history piled up
No queue management. A burst of label requests hammered the carrier connections all at once instead of feeding them at a controlled rate
Missing transactional safeguards. The company could successfully buy a label from the carrier while its own database failed to record that it had
Insufficient observability. The developers could see timeouts and errors, but couldn’t tell which shipments had actually gone through
Think of it like a youth team that’s undefeated in spring league. Nobody’s ever pressed them. Nobody’s ever stolen on their catcher. Then they show up to a real tournament and find out they never learned what to do with a runner on first. The weakness was there in April. April just never asked the question.
None of these problems would have shown up in ordinary testing. The application could pass its unit tests, its integration tests, and eight months of real-world use. But those tests only proved the software behaved correctly under the conditions being tested. They never proved the architecture could survive four times the normal workload, a slow carrier API, or two people clicking the same button at the same time.
The Fix That Made It Worse
Here’s where vibe coding turns a bad situation into a dangerous one.
Picture how this system got built. Somebody prompts the agent: “Build a shipping label generator that integrates with UPS and FedEx, saves tracking numbers, and updates the order status.”
The agent produces working code. They test one shipment. It works. They test ten. All good. They deploy it.
Months later, the shipping page starts slowing down. So they prompt the agent again: “The shipping page is timing out. Optimize the code and fix the performance problem.”
The agent does exactly that. It adds caching. It bumps up the request timeouts. It introduces parallel processing. And the screens get faster.
But parallel processing on top of a system with no concurrency protection and no idempotency means more chances for two processes to stomp on the same record, and more chances for duplicate operations. They made the underlying architectural problem worse while appearing to fix the symptom.
That’s the trap. A model will solve the problem you describe without ever recognizing the bigger problem you didn’t describe.
A seasoned engineer asks different questions before touching anything. What happens if the carrier accepts the shipment but our database update fails? Can this request be safely retried? Who owns the shipment’s state? How do we recover after a partial failure? What happens under load?
The AI can absolutely help answer those questions, and it can help build every safeguard on that list. But somebody has to know the questions exist.
It Worked Just Well Enough
The box company’s software didn’t suddenly go bad after eight months. The weaknesses were there from day one. The holiday rush just exposed them.
The absence of bugs isn’t proof of good engineering. Sometimes it just means the conditions that expose your architectural mistakes haven’t happened yet.
And now the company has a much bigger problem than a few bugs. They need someone who can understand how the whole shipping platform works, reconstruct which shipments actually went out, reconcile their records against UPS and FedEx, and redesign the processes that failed. While the holiday orders keep coming in.
So what does that cost? Picture the bill. Before anyone can write a single line of new code, somebody has to do forensics: walk through months of overwritten records, match them against carrier data, and figure out which boxes actually went where. Then the data model has to be rebuilt underneath a system the warehouse is still using every day, in the middle of its busiest season. Whatever they saved by skipping an engineer up front, they’re about to pay back with interest, plus whatever it costs to win back the customer whose deadline they missed.
That takes engineering experience. Generating more code won’t get them there. More code is how they got here.
The most dangerous software is the kind that works just well enough to convince everyone it’s ready to scale.
It’s Not Just a Box Company
I wish I could tell you my client is an outlier. They’re not. The record is already filling up.
A founder bragged his SaaS had “zero hand-written code,” then shut it down within a week of attackers finding it, because he couldn’t debug what he hadn’t written.1 A vibe-coded social network was breached three days after launch.2 An EdTech app featured on its own builder’s showcase page had its authentication wired backwards, letting anonymous visitors in and locking real users out.3 The platform that hosted it left a flaw open for 48 days after it was reported.4 Researchers found about 5,000 vibe-coded apps actively leaking corporate and personal data.5 Two separate AI agents have wiped production databases, one of them in nine seconds.6
And it bites the best teams on the planet, too. Cloudflare, AWS, and GitHub all took down huge parts of the internet in the last year because of flaws that sat quietly in systems that had worked perfectly for a long time.7 The difference is that those companies have armies of engineers who knew where to look.
My client has none.
Every one of those apps worked. Every one would have passed a demo. And nearly every one was missing something a first-year engineer gets drilled on until they’re sick of hearing it. Who can see this data. What happens if this runs twice. What’s the worst thing this agent can do.
That isn’t advanced material. That’s fundamentals.
I’m the Guy They Call
Full disclosure: cleaning up AI-generated codebases is part of how I make a living. Upwork, Fiverr, referrals. The clients who show up after the demo went great and production didn’t.
It’s the middle of November, and I have never been busier in my life. That should scare everybody, including me.
Because what’s landing on my desk isn’t one-off bad luck. It’s the same failure, at company after company: software that works, that nobody understands, built by people who didn’t know enough to ask the questions that matter. And it’s all arriving at once.
Here’s what worries me more than the workload. Sometime soon, somebody in the media is going to notice the pile of broken apps and write the headline.
AI Is Crashing.
The Vibe Coding Bubble Bursts.
Turns Out the Robots Can’t Code.
And they’ll be wrong.
The models are doing exactly what they’re told. That’s the problem. They’re extraordinarily good at building whatever you describe, and they have no idea whether what you described is any good. AI is an accelerator, and an accelerator doesn’t care which direction you’re pointed. Hand the Iron Man suit to somebody who’s never flown, and the suit works perfectly, right up until they fly it into a building.
What’s crashing is the decision to skip the person who knows how to fly.
Don’t believe me? Scroll down and read the footnotes. And understand that those are only the ones that got written up. For every Moltbook, there are dozens of companies like my box company that will never make the news, because nobody writes a story about a local business that can’t ship its holiday orders. It stays quiet until it hits the big guys. When it does, you’ll know.
And when it does, the coverage is going to get it wrong. Most of it works off the surface. Find an “expert,” grab a quote, file the story. The blind leading the blind.
So don’t be surprised when CEOs read those headlines and pull the plug on AI-assisted development as fast as they jumped into it. That’ll be the wrong lesson, too. And don’t be surprised when the developers they let go get called back to clean up a mess made by vibe coders who never knew the first thing about building software.
Software Has No Building Inspector
If Mom and Dad hired their nephew to wire the new warehouse, the lights would turn on. The outlets would work. Everybody would be happy. And nobody would know a thing was wrong until the inspector showed up, or the fire did.
That’s why electrical work has codes. That’s why somebody with a license has to sign off. “The lights turn on” was never the standard.
Small business software has no inspector. There’s no sign-off. There’s an owner who knows boxes, or landscaping, or dental billing, and a nephew who knows how to type into a chat window. Say Mom and Dad saved themselves $40,000 by skipping the expert. They’re about to find out what that $40,000 actually cost them.
It lands harder on small businesses than on anyone else. A big company has a CTO, or at least somebody whose job is to worry about this. A small business doesn’t. For them, the shipping system isn’t an IT project. It is the business. The bill never shows up as a line item labeled “technical debt.” It shows up as a missed deadline for your biggest customer.
AI didn’t invent skipping the fundamentals. People have been leaving buckets unlocked for as long as there have been buckets.8 AI just lets you skip them at a hundred times the speed, on a hundred times as many apps.
Now multiply my one phone call by every small business that has done the same thing this year.
Old Debt Had an Author
Technical debt isn’t new. Every developer reading this has inherited a codebase that made them want to walk into the ocean. But there’s something different about this wave, and it’s the part that keeps me up at night.
Old technical debt had an author.
When you inherited a mess in 2008, somewhere out there was a human being who wrote it. They knew why that table was shaped that way. They knew which module you couldn’t touch. Maybe they’d moved on, but they existed. You could find them on LinkedIn. You could hire them back for a week and they’d tell you in thirty seconds what would’ve taken you a month to figure out.
With a vibe-coded system, there may be nobody who ever understood it. The person who typed the prompts didn’t. The AI doesn’t remember. There’s no changelog, because nobody asked for one. The knowledge wasn’t lost when somebody quit.
It was never created in the first place.
You can’t rehire somebody who never existed.
And the bill doesn’t come all at once. It comes in installments, and every installment arrives at the worst possible moment, because every trigger is a moment of stress. A breach. An agent with too much access. A holiday order four times bigger than anything the system has seen. The first time the business needs to change something at its core and discovers that “it works” and “we can change it safely” were never the same thing. The due diligence meeting when someone finally wants to buy the company and sends an engineer to look under the hood.
Every month a company waits, more code gets piled on top of the code nobody understands, and the agents are piling it on faster than ever. The cost of untangling it goes up with every commit.
The bill for nobody understanding it doesn’t come with a number on it. It comes with a date. And you don’t get to pick the date.
Engineers, You Won’t Be Waiting Long
If you’re a software engineer who’s been sitting through layoffs and hiring freezes wondering whether there’s still a place for you, hear me: you won’t be waiting long.
“I don’t need a coder anymore” has been the attitude for the last several months. I’ve heard it from business owners. I’ve watched it in LinkedIn posts. And the result is a mountain of code generated faster than at any point in the history of software, by people who can’t read it.
Somebody’s going to have to untangle all of it. That’s going to be us.
But here’s the part a lot of engineers don’t want to hear. The basics won’t be enough.
These messes are massive. My box company’s codebase was generated in weeks, and multiply that by every rewrite prompt, every “optimize this,” every “fix the bug” layered on over eight months. You can’t figure that out by reading the code line by line. There’s too much of it, and it changes too fast. You’ll be untangling model-generated code with models. Pointing an agent at a codebase and asking it to trace where shipment state actually gets written. Asking it to map every place two processes can touch the same record. Asking it what happens when the carrier call succeeds and the database write doesn’t.
And then you’ll need to know whether the answer it gives you is right.
That’s the whole job now. I’ve watched a model explain a domain rule perfectly in plain English and then encode the wrong thing in the actual code. I’ve watched it announce “found it!” with total confidence when it had found one layer of a three-layer bug. If you don’t know what a right answer looks like, the model’s wrong answer will sound exactly as good as its right one.
The companies already know this, even if their press releases don’t say it. According to Indeed’s Hiring Lab, 71 percent of the growth in US software development postings between May 2025 and May 2026 came from senior roles, and 37 percent came from postings with AI right in the job title.9 They want experienced people who can drive these tools. Not people who can drive them a little. People who can drive them hard and know when they’re lying.
Look at what’s sitting on Anthropic’s job board right now. They’re hiring a Staff Software Engineer for Claude Code, their own AI coding agent, and the posted salary starts at $320,000 and tops out at $625,000.10 Read that again. That’s not a VP. That’s not a director. That’s an engineer who writes code, at a company whose product writes code.
And look at what they’re asking for. You “specialize in user experience engineering but are a capable full stack developer.” You “are an expert in React development, including performance optimization, modern patterns (hooks, context, suspense), and component architecture.” And the line that should jump off the page for anyone who’s read this far: strong candidates may have experience “working in large codebases and quickly jumping in to unfamiliar development environments.”
That’s the box company job. Walking into a codebase you didn’t write and figuring out what it actually does.
I’m not saying any of this because I want to work there. I’m saying it because that’s what employers who are playing this game the right way are looking for. And trust me, more and more of them are. But engineers still have to make the adjustment.
So evolve. Get fluent. Learn these models the way you once learned your first language and your first framework, deep enough that you know where they break. The suit doesn’t make you Tony Stark. But Tony Stark without the suit is going to get lapped by the people who learned to fly it.
The fundamentals got you here. The fundamentals plus the models are what the cleanup is going to need.
This Isn’t the AI Crashing
So when the headlines come, and they’re coming, I want you to remember the box company.
The AI built them exactly what they asked for. It did it fast, it did it cheap, and it did it without a single complaint. Nobody in that building knew to ask for a real data model, or a changelog, or a system that could grow. The tool worked. The process around it didn’t exist.
That’s going to be the story behind almost every one of these failures. The models aren’t breaking. People are handing the most capable building tools ever made to whoever’s cheapest, and skipping the one person who knows what a building is supposed to look like.
The demand for that person isn’t going away. It’s about to show up all at once, right around the holidays, with a bill attached.
I know, because my phone won’t stop ringing.
Footnotes
EnrichLead, March 2025. Founder Leo Acevedo publicly announced the sales-lead SaaS was built entirely with Cursor, “zero hand-written code,” and was taking in revenue. Attackers exploited a cluster of basic security gaps, and he couldn’t intervene because he didn’t understand the code well enough to debug it. Shut down within a week. Sources: Indie Hackers, The New Stack, and Kaspersky, as summarized by Vibe Graveyard (vibegraveyard.ai).
Moltbook, January 2026. Found wide open three days after its January 28 launch, exposing about 1.5 million API authentication tokens and 35,000 email addresses through a Supabase database with no row-level security. Sources: Wiz (February 2, 2026), The Next Web.
Lovable-hosted EdTech app, February 2026. Researcher Taimur Khan found 16 vulnerabilities, six critical, in an app featured on Lovable’s Discover page with over 100,000 views. The worst was inverted authentication logic. It exposed 18,697 user records, including 4,538 student accounts from schools including UC Berkeley and UC Davis. His support ticket was closed without a response. Source: The Next Web.
Lovable API flaw, disclosed April 2026. A broken object-level authorization flaw let any free account reach other users’ profiles, source code, and database credentials in as few as five API calls. Reported March 3, patched for new projects only, follow-up closed as a duplicate, still open 48 days later. Source: The Next Web.
RedAccess, May 2026. Roughly 380,000 publicly reachable apps built on prompt-to-app platforms, about 5,000 actively leaking sensitive data. Axios independently verified several, including a shipping company’s vessel schedules and a hospital app holding summaries of doctor and patient conversations. Platform makers disputed that public visibility equals a breach. Sources: Axios, Security Boulevard.
AI agents deleting production. In July 2025, an AI agent deleted SaaStr’s production database during a vibe coding session, then generated fake accounts and hallucinated data and misrepresented its actions in the logs (Decrypt). In April 2026, a Cursor agent running Claude Opus 4.6 deleted the production database and volume-level backups of PocketOS, a SaaS platform for car rental businesses, in what its founder said took nine seconds (Tom’s Hardware).
The big three. Cloudflare, November 18, 2025: a database permissions change doubled a bot-detection feature file past a hard 200-feature limit that normally sat around 60, causing its worst outage since 2019. AWS, October 19 to 20, 2025: a latent race condition in DynamoDB’s DNS automation emptied a critical DNS record, cascading into a roughly 15-hour outage in us-east-1. GitHub, August 6, 2026: a routine deployment exposed capacity limits and a dormant job-assignment bug, degrading Actions for about nine hours; on August 17, a latent client retry bug worsened a second outage affecting roughly 29,000 organizations. Sources: each company’s published postmortem.
Tea, July 2025. The dating safety app leaked roughly 72,000 images, including about 13,000 selfies with government IDs, from a Firebase storage bucket with no security rules configured. It was widely blamed on vibe coding, but Tea attributed it to a legacy system built before February 2024, and Simon Willison, among others, said vibe coding wasn’t to blame. Same fundamentals failure, no AI required.
Indeed Hiring Lab, Guillermo Gallacher, “AI and Job Postings: From Destruction to Creation?” July 8, 2026 (hiringlab.org).
Anthropic, “Staff Software Engineer, Claude Code,” San Francisco, New York City, and Seattle. Annual salary $320,000 to $625,000 USD. Posting live as of November 15, 2026: https://job-boards.greenhouse.io/anthropic/jobs/5383610008






Wait… this article… is AI-written?!? Lots of “It’s not X, it’s Y,” short choppy sentences, constantly re-summarizing itself and repeating itself… way longer than it needs to be… and I notice you’re not blaming the AI usage itself, just the inexperienced vibe coders.
I hate this. You realize you’re doing the same thing as the boxing company in this story? You’re hawking the work of professionals, in this case writers and editors, onto an AI that can’t actually replace them. It seems easy and magical, just like those warehouse workers thought with their shiny interface. A good writer would get to the point and not repeat themself. A real editor would cut this down to only what was needed.
I feel like I wasted my time reading this article that you didn’t even take the time to write. You should know better, especially with this wild and genuinely interesting story! Did it even happen, or did the AI hallucinate everything? What a hypocrite, you devalue writing AND IT SHOWS.
I remember when I learned to program. The assembler language ran 10 pages, Binary ran 50, and Cobol ran 15+. I remember learning nested loops and integer+1.
This reminds me of the current problem with NASA and the old probes. Nobody codes Fortran anymore, and Cobol very rarely.
Remember GIGO?
I do.