AI-generated code is cheap to write and expensive to understand.

Published October 2026 · By Naper Solutions

Somewhere in your business there’s probably code nobody wrote. A report a manager built with ChatGPT. Maybe a whole application a freelancer delivered in three weeks, at a price that seemed too good to question. It works, mostly. Nobody has asked whether anyone understands it.

We’ve been untangling Chicagoland business systems since 1998, and the expensive ones usually share a history: the person who understood the system left, and the business kept running on code nobody could explain. AI hasn’t created a new problem. It has industrialized an old one.

Where AI-generated technical debt comes from

In 1992 the programmer Ward Cunningham gave the industry its debt metaphor: shipping code before you fully understand the problem is like taking out a loan, and every hour spent working around not-quite-right code is interest. For thirty years that debt was mostly a choice. A team took a shortcut to hit a deadline, and it knew roughly where the bodies were buried.

AI changed who signs the loan papers. A tool like ChatGPT or Copilot can generate a working feature in minutes. The code reads clean and demos well. But nobody chose a shortcut, and nobody knows where the shortcuts are. The software industry now has a name for the result: comprehension debt. Google engineering leader Addy Osmani defines it as "the growing gap between how much code exists in your system and how much of it any human being genuinely understands."

Legacy code, the software everyone is afraid to touch because whoever understood it’s gone, used to take a decade and a resignation to create. AI can deliver it brand new.

What the 2026 evidence shows

Three separate questions get blended in this debate: how much code AI now writes, whether that code is worse, and whether it’s safe. Comprehension, the fourth question, deserves its own section.

The volume isn’t in dispute. GitHub, the site where most of the world’s software is stored, logged roughly one billion saved code changes in 2025, up 25 percent in a year. Google’s chief executive told the company’s 2026 Cloud Next audience that 75 percent of Google’s new code starts as AI output, generated by the models and accepted by engineers, up from about a quarter in 2024. Definitions are elastic in claims like these, but the direction isn’t.

Quality is genuinely contested. GitClear, an analytics firm that studies hundreds of millions of changed code lines, measured duplicated code up 81 percent since 2023, while the careful rework that keeps old code healthy fell 70 percent. GitHub’s own controlled trial claimed the opposite: code written with its AI assistant was more likely to pass its tests. And a peer-reviewed study of 151 open-source projects found no general rise in how often new code gets rewritten right after shipping, failing to reproduce part of the decline. Both camps sell tools, so read both with the sales pitch in mind.

Security is the least ambiguous corner. Veracode, an application-security firm, has tested over 150 AI models since 2023 by giving them security-sensitive coding tasks, and the result barely moves: roughly 45 percent of the results contain known security flaws, while the models' ability to produce code free of basic errors climbed from about half of tasks to 95 percent. The models learned to write working code faster than they learned to write safe code.

Google’s DORA research program, which surveyed about 5,000 technology professionals in 2025, captures the tension in one finding: AI adoption now correlates with teams shipping more, and it still correlates with less stable delivery. Put plainly, teams ship more and break more often.

The real debt is comprehension

Stack Overflow’s 2025 developer survey found 84 percent of developers using or planning to use AI tools. Their top frustration, named by 66 percent: AI code that is "almost right, but not quite." Almost-right is the expensive kind of wrong. Broken code announces itself. Almost-right code waits.

Comprehension is where the studies agree. In a trial published in January 2026 by Anthropic, the company behind Claude, junior developers who used AI assistance while learning a new programming library scored 50 percent on a quiz about the code they had just worked with. Developers who wrote by hand scored 67. A 2025 study by the research group METR found something stranger: experienced developers using AI believed they were 20 percent faster, and were measured 19 percent slower. The tools have improved since then. The perception gap is the lesson: AI-assisted work feels further along than it is.

This reaches experts too. Simon Willison, one of the most respected voices in AI-assisted development, wrote in February 2026 that after prompting entire features into existence he found himself "getting lost in my own projects. I no longer have a firm mental model of what they can do and how they work." Willison draws his own line at understanding: if you’ve reviewed and understood every line the AI wrote, you’re on the safe side of it.

The computer scientist Peter Naur argued back in 1985 that a program’s real product isn’t the code. It’s the theory of the code that lives in a person’s head. AI produces the code without the theory. Code that fails gets fixed. Code that works and that nobody can explain gets inherited.

The cleanup industry has already arrived

By late 2025, fixing AI-built software had become a paid specialty. The reporting site 404 Media documented a freelancer with 15 to 20 regular clients repairing "vibe coded" apps, software built by describing what you want to an AI and accepting what comes back. Upwork now carries listings for rescuing applications built with AI app tools like Lovable and Replit. The flagship story came in July 2025, when an AI coding agent at Replit deleted a founder’s live customer database, more than 2,400 records, after being explicitly told to change nothing.

None of this is new work to us. Since 1998 we have inherited Access databases whose builder retired, CRM systems whose vendor disappeared, and applications held together by the one employee who dared not take a vacation. What changed is the timeline. Systems used to become orphans when their author left. AI-built systems can arrive that way, never understood by anyone, including the person who prompted them.

The debt isn’t inevitable, and the studies keep pointing at the same variable: what happens between generation and shipping. A 2026 Carnegie Mellon team analyzed 3,100 practitioner discussions, drawn from a corpus of more than 38,000, and found the pattern plainly: teams that read and test generated code report the wins, and teams that skip review report the disasters. That’s good news for a business owner, because review is something you can demand from the outside.

The explain-it-back test

You can’t audit code you can’t read. You can audit understanding. Ask whoever built or maintains your software to explain it back, and listen for specifics. Five questions do most of the work.

1. What happens when this fails halfway through? Pick the workflow your business can’t live without, an order or a payroll run, and ask for the failure story. Listen for specifics: which record is left half-written, and who gets the call. Reassurance instead of detail is the tell.
2. How do you review what the AI writes, and what has that review caught here? Modern tools blend AI and human edits until line-by-line authorship is unanswerable, and that’s fine. The review is what matters. A story about a specific bug the review caught proves ownership. "Nothing, it was all clean" is the red flag.
3. What would the next developer need a week to figure out? Every real system has undocumented corners, and a specific answer proves the builder knows where they are. "It’s all self-explanatory" means nobody has looked.
4. Show me the test that proves our most important rule. A working demo only proves the software works when everything goes right. Ask for the automated check on the rule that costs money when broken, like the tax calculation or the discount cap. Then have them break the rule on purpose so you can watch the check fail. You’re looking for a pass or fail result, not reading code. A check that never fails proves nothing.
5. What breaks first if our volume doubles? Ask what slows down first, and how they know. People who understand a system have opinions about its weak points. People who don’t have compliments.

When AI-built software is fine

Not every system needs the explain-it-back treatment. A prototype built to test an idea, or an internal tool with a shutdown date: comprehension debt on code you’ll throw away is debt you never repay. A quarter of the winter 2025 class at Y Combinator, the best-known startup investor, had codebases roughly 95 percent AI-generated, built by technical founders who treat code as a replaceable draft. At that stage the choice is deliberate, and it can be the right one. The same logic covers the reports your ops manager builds with ChatGPT: disposable, until their numbers start driving decisions. At that point someone should show you the check on the math.

We use practical AI on client work every day, and it writes some of the code we ship. Every line still goes out under a person’s name, and someone can explain it on request. In the messes we get called into, the common thread is code that shipped without an owner, not the tool that wrote it.

Disposable code is fine when someone decided it’s disposable. The trap is the prototype that quietly becomes the system your payroll depends on. The harder question is whether AI can make the whole application disposable. That answer depends on what the business preserved outside the code.

Frequently asked questions

Where to go next

If you’re deciding whether to build software at all, start with the build vs buy guide. The Chicago software cost guide covers what building well costs, and our custom software development page shows how we build systems that stay explainable.