Strategy

The real cost of shipping unverified code

Editorial · Reveneau · August 27, 2026 · Updated November 16, 2026

The real cost of shipping unverified code

AI-generated code is safe to use in a business application when every change passes automated checks before it is released, and it carries a cost the business pays later when it does not. Reveneau writes all of its code with AI, and every change has to pass an eval suite written from the specification before it is released.

The cost of unverified code rarely appears as a line item. That is why teams pay too little attention to it: the cost arrives in four separate places, and only one of them looks like a software defect.

This piece is written for whoever has to approve the time. It uses outside research only, for reasons we explain at the end.

Is AI-generated code safe to use in a business application?

Yes, when each change has to pass checks that test security and the rules of your business before it reaches users. Without those checks, the research gives you no reason to trust it.

Two measurements show the range. Veracode, in its Spring 2026 update (published 24 March 2026, read 16 November 2026), reports that "only 55% of generation tasks result in secure code" across the more than 150 models it has evaluated, while syntax correctness exceeds 95 percent. Code can pass a syntax check and still be insecure.

A 2025 study by Maximilian Schreiber and Pascal Tippe (arXiv 2510.26103, read 16 November 2026) looked at 7,703 files on public GitHub that were marked as written by an AI tool. A scanner called CodeQL found no identifiable vulnerability of a known type in 87.9 percent of them. The language changed the result: Python showed vulnerability rates of 16.18 to 18.50 percent, against 8.66 to 8.99 percent for JavaScript.

The two numbers answer different questions. Veracode sets tasks chosen to test security. The GitHub study reads code that people kept and published, and a scanner finds only the problems its rules describe. Both say the same thing to a business: some share of generated code is unsafe, and you cannot tell which share by reading it.

So the question to ask a team is what has to pass before a change is released. The checks that matter most are permission rules, input handling, the packages the code adds, and the flows where money or data moves. What to do when a check finds something is in how to handle a security finding in generated code, and the checks to run before launch are in how to do a security review before launch. Reveneau takes responsibility for the whole project, through production and after release.

Cost one: the same defect, two prices

Take one bug. A permission check that stops working for users in a second organisation.

Caught by an automated check in a pull request, it costs minutes. An engineer reads a failed build, fixes the boundary, and moves on. Nobody else in the company ever learns it happened.

Caught by a customer, the same bug costs a support conversation, an escalation, an engineer taken off whatever they were doing, a diagnosis, a fix, an out-of-band release, a retrospective, a note to whoever was affected, and some amount of trust that does not come back on a schedule.

The gap between those two prices is the argument for verification, and it needs no invented statistic.

Cost two: senior attention spent on the wrong job

Your most expensive engineers are, right now, reading diffs to work out whether they function. Mentally executing code against unusual cases. Checking whether a boundary condition was handled.

That is the one part of their job a computer does better than they do. A check is exact, it does not tire, and it stays as accurate as the diff gets longer, while human attention drops.

In a randomised controlled trial published on 10 July 2025, METR gave 16 experienced open-source developers 246 real tasks in codebases they knew well. With AI tools they took 19 percent longer, and afterwards estimated AI had made them 20 percent faster. METR's page now says "These results are out of date" and points to newer results current as of early 2026. The point we take from it is narrower: skilled professionals could not tell which direction their own performance had moved. If intuition cannot measure speed, it should not be the step that approves correctness.

Move the mechanical checking to a machine and the same people spend their week on design, on product judgment, and on whether the thing was worth building. That moves your scarcest people to better work, and it rarely appears in any business case because nobody bills for it.

Cost three: the codebase nobody will change

This cost is the one almost nobody puts in a document, because it looks like caution.

When a team cannot prove that a change is safe, it stops making changes. The dependency upgrade gets deferred. The refactor that would make the next three features easy never happens. A module becomes known as risky, and then the team gives it a nickname. New work avoids it, adding a layer instead of fixing the thing, and each layer makes the next change harder.

Most of what people call technical debt is this: code nobody dares change, because nobody can prove a change to it is safe. A check can change that. Capture what a module the team is afraid of currently does with fixtures, assert the outputs, and it becomes editable again, sometimes without changing a line of it. We wrote up that technique in adding evals to an existing codebase, and our wider view on debt is in what is technical debt and when to pay it.

This cost grows over time. Every month the code stays unchanged makes the next change more expensive.

Cost four: a pipeline nobody believes

The last one is about the team's habits, and it cancels the gain from everything else.

Once engineers stop trusting a passing build, they compensate. They re-run builds. They review defensively. They add manual checking before release. They avoid letting an agent work unattended, which removes the speed advantage that justified the tooling in the first place.

At that point you are paying for the suite and getting no value from it. And the trust is broken by specific, identifiable things: checks that cannot fail, flaky checks, and checks that mirror the implementation. All three are fixable, and all three have to be searched for, because a list of passing checks does not report them. The warning signs are in when evals give false confidence.

The pattern to watch for in your own numbers

There is a documented pattern to this, and you can check your own data against it this week.

Google's DORA program surveyed nearly 5,000 technology professionals for its 2025 report on AI-assisted software development. Ninety percent use AI at work. More than 80 percent believe it makes them more productive. And AI adoption showed a positive relationship with delivery throughput alongside a negative relationship with delivery stability. More changes reaching production, and a higher share of them going wrong.

DORA's own summary is that AI "amplifies what's already there". Strong verification, and you get faster delivery. Weak verification, and you get faster rework, which feels like speed until the rework arrives.

So look at your throughput next to your change failure rate and your rework rate. If the first is up and the other two are up with it, you are delaying the cost, and it arrives later as incident load and as parts of the codebase becoming unmaintainable. The measures worth tracking are in metrics for AI code quality.

What the fix costs

Less than the framing usually implies, provided it is not run as a project.

One critical flow is a day or two: write down what must always be true as plain sentences, turn each into an automated check, add them to the pipeline as a required check that blocks a release. Three flows is two or three weeks. After that the suite grows inside normal work, because the rules are to cover the area you are about to change and to turn every defect that reached users into a permanent check.

The version that fails is the testing initiative with a coverage target running for a quarter. It produces a large number of low-value tests around the easiest code, gets cancelled when a deadline arrives, and then gets quoted for years as evidence that testing does not pay. Avoid it. Start with three flows and stop.

Why this piece has no number of our own

This piece gives no percentage for what verification saves. Nobody at Reveneau has run the controlled experiment that would justify one, and a company that takes responsibility for its projects should not publish figures it cannot show the working for.

If you want numbers for a business case, use the ones above: DORA on throughput and stability, Veracode on 55 percent of generation tasks producing secure code while syntax correctness exceeds 95 percent, the GitHub study on how the result changes with the language, and METR on how professionals misjudged their own speed with AI tools. People with no interest in what you decide measured them, which makes them worth more than any claim a company makes about itself.

Unverified code delays its cost, and whoever has to change it next pays more than the check would have cost.

Related guide: Eval-driven development: how to prove AI-written code works.

Sources

Common questions

Is AI-generated code safe to use in a business application?

It is safe when every change passes automated checks before release, and unsafe without them. Veracode's Spring 2026 update found only 55 percent of generation tasks produced secure code, while a 2025 study of 7,703 AI-attributed files on public GitHub found no identifiable vulnerability in 87.9 percent. Reveneau writes all of its code with AI, and every change has to pass an eval suite written from the specification before it is released.

What does unverified code cost a business?

Four things: rework on defects that reach customers, senior engineering attention spent verifying diffs by hand, a codebase nobody will change because nobody can prove a change is safe, and the loss of trust in the pipeline that makes every automation gain exist only on paper. Only the first shows up in a bug tracker.

Why does a defect caught late cost more?

Because the fix is the smallest part of the cost. A defect found by a customer brings a support conversation, an out-of-band release, a retrospective, the interruption of whatever the team was doing, and some lost trust, while the same defect caught by a check in a pull request costs an engineer minutes.

What is the connection between unverified code and technical debt?

Most of what teams call technical debt is code nobody dares change, and code becomes untouchable when there is no way to prove a change did not break it. Adding a characterisation check to a module the team is afraid of often makes it editable again without any refactor at all.

Does AI-assisted development increase or decrease delivery risk?

It does both, and the 2025 DORA research across nearly 5,000 respondents found AI adoption raising throughput while lowering delivery stability. The report describes AI as something that makes existing practice stronger, good or bad, which means the risk depends on whether automated verification scaled with the volume of code.

How much does it cost to start verifying?

A day or two per critical flow, and two or three weeks for the three flows where a silent failure would cost the most. The expensive version is a quarter-long testing initiative with a coverage target, which tends to stop making progress and then gets cited as evidence that testing does not pay.

How do I make the case to someone who thinks the team is already fast?

Show the throughput number next to the change failure rate and the rework rate. A team releasing more while breaking more is delaying costs, and those costs are paid later in incident load and in the areas of the codebase that become unmaintainable.

What should we measure to see this cost?

Track change failure rate, failed deployment recovery time, escaped defects, and the share of changes that revise something released in the last 30 days. Volume metrics stopped carrying information once producing code became cheap, so a team that only counts commits or pull requests merged will see a false picture of how well the pipeline works.

Is unverified code ever an acceptable trade?

Yes, for disposable work: a prototype that will be deleted, an internal script, an experiment whose only purpose is to answer a question. The trade goes wrong when a prototype becomes the product without anyone deciding that it had, because by then the codebase carries production risk with none of the checks that production work is supposed to have.

What is the first thing to fix on a codebase with no verification?

Fix the flows where failure is expensive and quiet: permissions, money movement, data deletion, and the numbers customers make decisions from. On an AI-built codebase, start with security and permission assertions, since generated code tends to work well in normal use and is weakest exactly there.

How does this affect a company being acquired or audited?

A trustworthy check suite is one of the few documents that describes what the software guarantees in practice, so it makes diligence faster and cheaper. Its absence usually turns into a list of unquantified risks in a report you do not control.

Start a project