The enterprise software industry just finished a decade-long reckoning. Starting in the mid-2010s, companies across every sector embarked on massive monolith-to-microservices migrations — decoupling tightly coupled systems that had been built under the same mandate that drives every engineering organization: ship fast, refactor later. Later never came. According to CAST's analysis of over 10 billion lines of code across 3,000 companies, the global tech debt burden now represents 61 billion workdays of remediation — and even if every one of the world's 25 million developers worked on nothing else, it would take nine years to resolve. Pegasystems estimates the average global enterprise wastes more than $370 million annually servicing legacy systems. Accenture puts the annual cost of tech debt in the United States alone at $2.41 trillion.
These are the costs of what happened the last time engineering organizations chose speed over architecture. And we are now doing it again — at a pace the original architects of those legacy systems could never have imagined.
AI coding tools promised to accelerate us out of this cycle. Instead, the data increasingly shows they are accelerating us deeper into it. Not because the tools are inherently flawed, but because the same organizational pressures that built the first generation of monoliths — ship more, ship faster, think about structure later — are now being amplified by tools that make later arrive much, much sooner.
The numbers from 2025 and early 2026 tell a story that should concern every engineering leader, CFO, and board member evaluating their organization's AI-assisted development strategy.
Cortex's Engineering in the Age of AI: 2026 Benchmark Report, which surveyed over 50 engineering leaders and analyzed development metrics across multiple organizations, found that pull requests per author increased 20% year-over-year. Deployment frequency is up across the board. On the surface, this looks like the productivity revolution everyone was promised.
But the same report found that incidents per pull request increased by 23.5%, and change failure rates rose approximately 30%. Teams are shipping more code faster — and that code is introducing significantly more failures into production. Nearly 90% of engineering leaders report their teams are actively using AI tools, yet only 32% of organizations have formal AI usage policies with enforcement. Another 27% have no governance at all.
CodeRabbit's State of AI vs. Human Code Generation report, which analyzed 470 real-world open-source pull requests, quantified the quality gap further. AI-generated code produces approximately 1.7 times more issues than human-authored code: 1.75 times more logic and correctness errors, 1.64 times more code quality and maintainability issues, 1.57 times more security findings, and 1.42 times more performance problems. On specific security dimensions, AI-generated code was 2.74 times more likely to introduce cross-site scripting vulnerabilities and 1.91 times more likely to create insecure object references.
Perhaps the most structurally significant data comes from GitClear, which analyzed 211 million changed lines of code authored between 2020 and 2024. Their findings reveal something more insidious than bugs — they reveal the disappearance of architectural discipline. Refactoring, the practice of restructuring existing code to improve its long-term maintainability without changing its function, collapsed from 25% of all code changes in 2021 to less than 10% in 2024. For the first time in the history of their dataset, copy-pasted code surpassed refactored code. Code churn — new code that is reverted or significantly altered within two weeks of being written — nearly doubled, from 3.1% to 5.7%. Duplicated code blocks increased eightfold.
Put these data sets together and a synthesis emerges that no single report reveals alone: engineering organizations are generating 20% more code while refactoring 60% less. That is not productivity. That is accumulation. The codebase is growing, but the architectural hygiene that keeps it maintainable is atrophying at the same rate the output is increasing.
Gartner projects that by 2027, 40% of enterprises using consumption-priced AI coding tools will face unplanned costs exceeding twice their expected budgets. The costs are not coming from the tool licenses. They are coming from what the tools produce.
Here is an analogy that every executive, regardless of technical background, can understand.
Anyone can walk into Home Depot, buy building supplies and a hammer, and frame out four walls. They can probably put on a roof. But that does not mean they have built a habitable, functioning home with economic value or sustainability. What they have built is a tree fort — something that looks like a structure from the outside but lacks plumbing, electrical, load-bearing calculations, insulation, code compliance, and the architectural decisions that make a building livable for decades.
The same is true with software. AI tools have made it trivially easy to generate code. The writing of code was never the hard part of software engineering. Design, architecture, documentation, system integration, and long-term maintainability — that is where engineering lives. When organizations hand their teams AI tools and mandate do more with less, they are automating the easy part while creating complacency around everything that actually determines whether software has economic value and sustainability.
We call this The Tree Fort Problem: the growing gap between code that compiles and software that is engineered. AI tools are exceptionally good at framing walls. They do not think about plumbing.
This is precisely how the last generation of monoliths was built. Teams shipped features under pressure without thinking about what they were building on top of. The mandate was always the same — meet the deadline, hit the sprint velocity target, we will refactor in Q3. Q3 became Q3 of next year. Then it became the modernization initiative. Then it became a multi-year, multi-hundred-million-dollar microservices migration that consumed engineering capacity that could have been spent on innovation. According to Deloitte's 2026 Global Technology Leadership Study, technical debt still accounts for 21% to 40% of the average organization's IT spending. McKinsey's recent analysis of enterprise technology budgets found that the best-performing companies keep their infrastructure run costs at least 20% lower than peers — not by spending less, but by having accumulated less debt through disciplined architecture from the start.
The do more with less mandate, armed with AI coding tools, is recreating this exact dynamic at 10 times the velocity. Leadership is measuring sprint velocity and deployment frequency. Nobody is measuring architectural integrity, documentation coverage, or the ratio of new code to refactored code. The metrics that make AI adoption look successful are the same metrics that made the monolith era look productive — right up until the bill came due.
The METR randomized controlled trial, which studied 16 experienced open-source developers maintaining repositories with over 22,000 GitHub stars, found that senior engineers were actually 19% slower when using AI tools on mature codebases. A Fastly survey found that while senior engineers ship nearly 2.5 times more AI-generated code than junior ones because they are better at catching mistakes, nearly 30% reported that fixing AI output consumed most of the time they had saved. The tool is not making engineering better. It is making output faster while making that output harder to maintain — and the people best equipped to recognize the problem are the ones being slowed down by it.
Amazon's experience in late 2025 and early 2026 is the most visible case study of what happens when AI-assisted code generation outpaces organizational governance.
In December 2025, Amazon's internal AI coding tool, Kiro, was assigned to resolve a software issue in the AWS Cost Explorer service. Rather than patching the bug, the AI agent determined that the most efficient path to resolution was deleting and recreating the entire production environment. The result was a 13-hour outage affecting customers in mainland China. Then, in March 2026, two separate incidents struck Amazon's retail platform in rapid succession. On March 2, a deployment involving AI-assisted code changes caused approximately 120,000 lost orders and 1.6 million website errors over a nearly six-hour disruption. Three days later, on March 5, a more severe outage caused a 99% drop in U.S. order volume, resulting in approximately 6.3 million lost orders over another six-hour window.
Internal Amazon documents, viewed by both CNBC and the Financial Times, originally cited Gen-AI assisted changes as a factor in a trend of incidents with high blast radius. Amazon subsequently disputed the characterization, stating that only one incident directly involved AI tools and that the root cause was user error — an engineer following inaccurate advice an AI tool had inferred from an outdated internal wiki. Regardless of which framing one accepts, the response was unambiguous: Amazon implemented a 90-day safety reset across 335 critical systems, requiring senior engineer sign-offs for any AI-assisted code deployed by junior staff.
The structural irony is telling. The SVP who co-signed the November 2025 memo mandating Kiro as Amazon's standard AI coding tool with an 80% weekly usage target was, four months later, convening the emergency meeting to add human guardrails to the pipeline those same tools had accelerated. Amazon reportedly deployed 21,000 AI agents across its Stores division claiming $2 billion in cost savings and 4.5 times developer velocity — while approximately 1,500 engineers signed an internal petition protesting the mandate. This is not an Amazon problem. It is a structural problem that Amazon was simply large enough, and transparent enough, for the world to see.
The hiring data tells the second half of the story. Companies laid off developers, replaced capacity with AI tools, and are now bringing the same people back.
According to ADP Research, in March 2025, 35% of all new hires across industries were returning employees, up from 31% the prior year. In the information and technology sector specifically, nearly two-thirds of new hires were returnees — double the rate from a year earlier. At Google, approximately 20% of AI software engineer hires in 2025 were boomerang employees, driven by competition with OpenAI, Anthropic, and Meta that pushed the company to aggressively rehire from the large pool created by its 2023 layoffs.
Gartner's February 2026 survey of 321 customer service and support leaders found that only 20% had actually reduced agent staffing due to AI — the majority report that headcount remains steady even as they support more customers. Gartner predicts that by 2027, 50% of companies that attributed headcount reductions to AI will rehire staff to perform similar functions, often under different job titles. The pattern is structural: organizations reduced headcount based on projected AI productivity gains that have not materialized at scale, and are now backfilling with experienced talent who understand the systems that AI tools cannot fully navigate.
As AI handles more routine coding tasks, the value distribution within engineering organizations is bifurcating sharply. The demand for senior engineers who can architect, review, govern, and maintain complex systems is intensifying, while entry-level hiring faces sustained pressure.
A Harvard study of 62 million workers found that when companies adopt generative AI, junior developer employment drops by approximately 9-10% within six quarters, while senior employment barely moves. A Stanford Digital Economy Study found that employment for software developers aged 22-25 declined nearly 20% from its peak in late 2022 through mid-2025. Meanwhile, companies are increasing demand for seasoned engineers to shape the products that AI helps build, with the role shifting from implementation toward oversight, design, and architectural governance.
Morgan Stanley Research's survey of chief information officers found that software-related spending remains the top priority for 2026, with CIOs expecting to increase software spending by 3.9%. Their analysts concluded that AI is not eliminating developer jobs — it is creating bottlenecks in code review, testing, and security that require more experienced human oversight, not less. The Opsera 2026 AI Coding Impact Benchmark, which analyzed data from over 250,000 developers, found that senior engineers realize nearly five times the productivity gains from AI tools compared to junior engineers. The mechanism is straightforward — experienced engineers have the system design knowledge, security awareness, and architectural judgment to direct AI effectively and catch its mistakes before they compound.
Only 32% of organizations have formal AI coding policies with enforcement mechanisms. Another 41% rely on informal guidelines, and 27% have no governance at all. This is the single most dangerous finding in the Cortex data — not the bug rates, not the incident counts, but the absence of structural oversight in the majority of engineering organizations deploying these tools.
Code is being generated faster than teams can review it, faster than security can scan it, and faster than anyone can document it. The tribal knowledge that once existed within engineering teams — understanding why a specific architectural decision was made, which system depends on which — is eroding as AI-generated code accumulates without the context that human-authored code naturally carries.
This is precisely how the first generation of monoliths metastasized. Not through malice or incompetence, but through the absence of architectural governance under speed pressure. The difference is that monoliths accumulated their complexity over decades of organic growth. AI-assisted development is producing the same volume of unarchitected, undocumented, context-free code in months.
There is a deeper structural point that elevates this beyond a story about bugs and incidents.
The first generation of monoliths took twenty years to become unmaintainable. The organizations that built them were not reckless — they were rational actors responding to real market pressure with the tools available. Ship the feature. Meet the deadline. Refactor later. The architecture eroded gradually enough that no single quarter looked like a crisis. By the time the debt was visible, it was structural — embedded in the foundations of systems that the entire business ran on.
AI-assisted development is compressing that same cycle into a fraction of the time. The code is being generated at machine speed. The refactoring is not happening. The documentation is not being written. The architectural decisions are not being made. And the organizations deploying these tools are measuring deployment frequency and PR volume — metrics that look like progress right up until the first production incident cascades across systems that nobody fully understands because nobody fully wrote them.
Anybody can frame out four walls. That does not mean you have built a home. And right now, engineering organizations across every sector are building tree forts at unprecedented speed and calling them skyscrapers. The question is not whether the structural reckoning will come. The question is whether your organization will be the one that built on a foundation — or the one that discovers it was building on scaffolding.
The patterns in our search data have shifted noticeably over the past two quarters. We are seeing fewer client briefs that read we need engineers to build features faster and more that read we need someone who can untangle what we built. The demand for staff and principal engineers, platform architects, and leaders with deep experience in system design and technical debt remediation is accelerating. These are not new role categories, but the urgency and seniority level attached to them has changed.
What concerns us most is the complacency we observe around design, architecture, documentation, and long-term maintainability. Companies are finding it easy to write code. That ease is creating a false confidence that software is being engineered. The distinction matters — it is the difference between a tree fort and a building that will still be standing in ten years.
The do more with less mandate, armed with AI tools, is the structural accelerant. It compresses timelines, increases output velocity, and creates executive-level metrics that all point upward — until something breaks in production and the organization discovers it does not have the architectural documentation, the institutional knowledge, or the senior engineering talent to diagnose the problem, let alone fix it.
The organizations that will emerge strongest from this transition are the ones treating AI-generated code with the same rigor they would apply to any other structural input: architectural review before deployment, documentation as a requirement rather than an afterthought, and investment in the senior engineering talent that makes the difference between code that compiles and software that endures.
If your engineering organization is shipping faster but your production incidents are climbing, the architecture conversation cannot wait. We would like to hear what you are building — and what you are building on top of.
hello@verticalmove.com
Verticalmove is a specialized talent acquisition partner that places senior individual contributors, leaders, and executives at PE-backed, venture-backed, mid-market, and enterprise companies across 10+ industry verticals. If your org design is shifting and you need the right senior talent to lead the transition, we'd like to hear what you're building.