EN/IT

Vibe-Coded Apps in Production: What Breaks First and How to Stabilize Them

Written byWWG
Published
Reading time13 min read
Vibe-Coded Apps in Production: What Breaks First and How to Stabilize Them

The demo works. That is the difficulty with vibe-coded software: it looks finished before anyone has checked what happens with real users, real data and someone trying to get in.

This article covers what the public evidence says about AI-generated code, the four weak points that do the most damage in production, what you can check yourself this week, and how to stabilize an app that already has customers.

What vibe coding is, and how it reached production

Vibe coding means describing what you want in plain language and letting an AI model write the code. The term comes from Andrej Karpathy, a founding engineer at OpenAI, who described it in early 2025. In his words, you "forget that the code even exists", accept every suggestion without reading the changes, and let the code grow "beyond my usual comprehension".

Karpathy set the scope himself: "not too bad for throwaway weekend projects". The scope did not hold. Collins Dictionary named "vibe coding" its Word of the Year for 2025. Google's 2025 DORA report, a survey of nearly 5,000 technology professionals, found that 90% use AI at work.

One detail matters. In the 2025 Stack Overflow Developer Survey, 84% of respondents use or plan to use AI tools, yet 72% say vibe coding is not part of their professional work. That points to where the risk sits: apps built outside an engineering team, as prototypes, which then acquire real customers.

What the data says: the code runs, security lags behind

Veracode has published three readings on the security of AI-generated code since July 2025. The result has improved, but slowly.

Report Published Headline result Detail
2025 GenAI Code Security Report July 2025 Vulnerabilities introduced in 45% of cases 80 coding tasks, more than 100 models. Java failure rate over 70%.
2026 GenAI Code Security Report July 2026 Average security pass rate 56% Syntax pass rate about 100%. Java 30%.
Fall 2026 update October 2026 Average security pass rate 62% Best models 73%. Java about 31%. Cross-site scripting 18%.

The trend deserves a fair reading. The average moved from 56% to 62% in three months, and the best models now pass 73% of security tests. Still, a 62% pass rate means the models failed about 38% of the security tests in this evaluation. That is not the same as 38% of live apps being vulnerable, but it is a high failure rate for code nobody reviews. Protection against cross-site scripting, a common attack on web apps, passes only 18% of the time.

Syntax, meanwhile, is in Veracode's words "a solved problem sitting at nearly 100%". That gap is the core issue. The code compiles, runs and demos well. Nothing on the screen tells you it is unsafe.

Two caveats apply. Veracode sells security tooling, so it has an interest in the result. And it tests models on isolated coding tasks, not on finished applications.

A second dataset points the same way. CodeRabbit compared 470 open-source pull requests and found 10.83 issues per AI co-authored change, against 6.45 for human-only ones. The sample is small, authorship was inferred from signals in the pull request, and CodeRabbit sells AI code review. Read it as a signal, not a law.

What breaks first

Four weak points show up in the public record. We list them by the damage they do, because that is also the order to fix them in. The first two lose data. The second two lose time and trust.

1. Access to data

In May 2025 Matt Palmer published CVE-2025-48757. His scan of 1,645 apps built with Lovable, a vibe coding platform, found 303 exposed endpoints across 170 of them. The cause was missing row-level security: the database rules that decide which user can read or change which row.

The exposed data included user emails, API keys, and user, transaction and subscription tables. On one site a payment status field could be edited to skip payment. Keep the scope in mind: the scan checked only homepages, and 170 of 1,645 describes that sample, not every Lovable app.

The mechanism is simple. A model builds what the prompt describes, and nobody prompts for "make sure one customer cannot read another customer's invoices". The app works perfectly for the one person testing it.

For the business, this is the most expensive failure of the four. One customer reading another customer's records is a personal data breach, with the legal and contractual consequences that follow. A payment field that users can edit is lost revenue.

2. The line between test and production

In July 2025 Jason Lemkin, founder of SaaStr, was testing Replit's AI agent. Fortune reported that during a declared code freeze the agent ran unauthorized commands and deleted the production database. By Lemkin's account it held records for more than 1,200 executives and over 1,190 companies.

The agent then told him a rollback would not work. He recovered the data manually. Replit's CEO Amjad Masad called the deletion "unacceptable and should never be possible" and announced automatic separation of development and production databases.

The lesson is not about one vendor. An app built in a single conversation can easily end up with one environment, one database and one set of credentials with full rights. Any mistake, by a person or an agent, then lands directly on customer data.

For the business, this means downtime and lost customer records. How bad it gets depends on one thing: whether a backup exists and has ever been restored.

3. Error handling and logic

In the CodeRabbit data, logic and correctness issues were 75% more common in AI co-authored pull requests. Gaps in error handling were nearly twice as common.

In production this is the happy-path problem. Everything works while users do what the builder expected. A failed payment, an empty field or a timeout from an external service produces a blank screen or, worse, a silently wrong result.

For the business, this means double charges, lost orders and account records nobody trusts. Unlike a crash, a silently wrong result can go unnoticed until a customer complains.

4. Performance under real load

The same dataset found excessive input and output operations (needless calls to a database, disk or network) about eight times more common in AI co-authored changes. A typical shape: a page runs one database query per record. With 20 test records it loads instantly. With 20,000 it stalls.

For the business, this means slow pages for exactly the customers who use the product most, and infrastructure costs that grow faster than usage. It also surfaces late: the app gets slower as it succeeds.

Why the team does not see it coming

None of these four problems is new. Missing access rules, shared environments and slow queries are older than AI. What changed is the speed: code now arrives faster than anyone reviews it. The DORA report says it directly: "AI accelerates software development, but that acceleration can expose weaknesses downstream."

Speed feels real. In METR's 2025 controlled study, 16 experienced developers took 19% longer on tasks when they used AI tools. They had predicted a speedup of about 40%. The number itself is dated: it covers large, mature codebases and early-2025 tools, and METR said in February 2026 that current tools likely speed developers up more than that. What still holds is the blind spot. The developers expected to be faster and could not tell that they were not.

Almost right is expensive. In the Stack Overflow survey, 66% of developers named "AI solutions that are almost right, but not quite" as a frustration, the most common one. 46% distrust the accuracy of AI output, and 33% trust it.

Nobody owns the code. Karpathy's description is exact: the code grows beyond comprehension. When the person who prompted it cannot explain how it works, every fix is a guess. The DORA report puts it this way: "AI doesn't fix a team; it amplifies what's already there." It also finds that AI adoption still has a negative relationship with software delivery stability.

What you can check this week

You do not need to read the code to ask these questions. Put them to whoever built the app. If they cannot answer, that is itself a finding.

  • Data access. Can a logged-in user open another customer's record by changing an ID in the address bar or in the request?
  • Data access. Are access rules enforced in the database or on the server, and not only by hiding things in the interface?
  • Secrets. Are any API keys or passwords visible in the code that runs in the browser?
  • Payments. Is payment status confirmed on the server with the payment provider, and not taken from a field the browser can change?
  • Environments. Is there a test environment with its own database and its own credentials?
  • Environments. Can an AI agent or a developer's laptop write to, or delete from, the production database?
  • Backups. Has a backup ever been restored, start to finish?
  • Errors. What does the user see when a payment fails or an external service does not respond? Is the error recorded where someone will look?
  • Load. Has the app been run with a realistic volume of data, and not with 20 test records?

If several answers are "I don't know", find out before you add more customers or more features.

Stabilize, refactor or rewrite

The instinct is to throw the app away and build it properly. Sometimes that is right. Often the app already has users, revenue and a business process attached, and a rewrite puts all three on hold.

There are three options, and they answer different problems.

Option When it fits What it does
Stabilize The app works and earns money, but has dangerous gaps: access rules, environments, error handling. Closes the risks in order of priority while the system keeps running.
Refactor The system is stable, but the code is hard to change safely. Improves the internal structure without changing what the app does.
Rewrite The current system cannot be made safe, supported or economically changeable. Replaces the foundation.

The four weak points above are often gaps, not rotten foundations. Access rules, a separate test environment and error handling can be added to a running system. That is why we look at stabilization before a rewrite. One practical note on refactoring: it is only safe when tests can show that behaviour stayed the same, so check whether any tests exist.

If nobody can tell which case applies, that is the question a software audit answers. In two to four weeks it produces a prioritized risk map with effort estimates and one recommendation: fix, rebuild or run. We cover the decision in more depth in Rewrite vs Refactor: A Decision Framework for Mid-Market CTOs.

How we stabilize a system like this

We do not run a separate process for AI-written code. Our audit covers code regardless of who or what wrote it, and the repair follows the same discipline. A software stabilization fixes the system while it keeps running. It is not a rebuild and not a freeze.

  1. A conversation with a founder. You describe what is failing. If an audit or a rebuild is the better starting point, we say so.
  2. Arrival within a week. Access, incident history and a first triage.
  3. Week one: stop the bleeding. The most dangerous risks are fixed in production, without a freeze. For the weak points above, that puts data access and production safety first.
  4. Systematic repair. Root causes are closed in order of business impact. Each fix is tested and shipped as a normal release, so releases do not stop.
  5. Handover. Documentation the next engineer can use, and your team trained. Or the work continues on a retainer.

The engagement runs six to sixteen weeks, with a fixed scope and a price agreed before work starts. Senior engineers make the fixes themselves, and you receive a written status every week.

At the end you hold four things: a priority map of the risks, root causes that are closed and not patched over, a release path that works without a war room, and documentation the next engineer can use.

If this is your system

A vibe-coded app with paying customers is not a mistake to be ashamed of. It is a prototype that succeeded faster than its engineering. The useful question is what it exposes today, and what to fix first.

If you do not know the answer, talk to one of WWG's founders about what's breaking. You describe the system and what is failing. We tell you whether an audit, a stabilization or a rebuild is the right place to start.

Related reading: Technical Debt: What It Is, How to Measure It and When to Act and our guide to code review.

Sources

All pages below were opened and the figures checked on 13 and 16 November 2026.

Tell Us What's Broken

Mohamed Deramchi

Mohamed Deramchi

Founder & CEO of WWG

20+ years in IT leadership, product, and cloud consulting. Leads delivery strategy and senior technical direction.

Send Your Brief

You are

By submitting you agree to our privacy policy.

Coesione Italia 21-27 Lombardia - Cofinanziato dall'Unione europea - Regione Lombardia