Legacy Migration May Become AI's Largest Enterprise Market

Most of what a large enterprise knows about its own business isn't written in a strategy document. It's written in code. Pricing logic refined over twenty years of edge cases. Risk models tuned by underwriters who left the company a decade ago. Compliance rules encoded one regulatory change at a time, going back to whenever the system was first built. This is the most accurate record the organization has of how it actually operates, and most of it is currently unusable for anything except running exactly as it already runs.

That's the real cost of legacy systems. Decades of accumulated business value sit locked inside infrastructure too risky to modify and too brittle to integrate with anything built in the last ten years. The knowledge is real. The access to it is not.

AI may be the first technology with the structural characteristics needed to unlock it.

The System Everyone Avoids

Every large enterprise has one: a system that runs payroll, or settles transactions, or calculates insurance premiums, that nobody wants to be the one to break. It has been running for as long as The Simpsons has been on air. The people who wrote it are retired or work somewhere else. The documentation, if it ever existed, gone too. What remains is the code and the quiet understanding that altering it carries real risk.

Migration projects are expensive, slow, and failure-prone. They require deep institutional knowledge and a tolerance for risk most organizations can't sustain. So the rational response, followed for decades, has been to leave the systems alone and build around them.

That action has a cost most balance sheets don't capture. The logic trapped inside these systems isn't idle. It actively constrains what the organization can do. A pricing engine that can't be safely modified gets workarounds bolted on instead of clean integration. A claims system that can't be queried by modern tools keeps decades of risk data siloed from the models that could use it.

Why the Math Never Worked

The pattern is familiar: an organization commissions a migration project, watches it balloon in scope and cost, and either abandons it or finishes years late at multiples of the original budget. The problem isn't engineering competence. It's information asymmetry. Legacy systems are opaque by design, with edge cases handled by code nobody wrote intentionally, but accumulated through years of patches. Migrating accurately requires understanding the system completely first, which means reading code that wasn't written to be read and reconstructing reasoning that the original authors are no longer around to explain.

That work is slow, hard to parallelize, and competes directly with feature delivery. So most enterprises carry the liability indefinitely. Gartner research consistently finds that organizations spend 60–80% of their IT budgets maintaining existing systems, leaving little room for anything else, including the work of making old systems legible enough to build on.

Why AI Changes This

Migration work has a structure that plays to AI's strengths: pattern-heavy translation across large volumes of code. Converting COBOL to Java, or a monolith to microservices, isn't intellectually novel work. It's repetitive work that requires sustained attention and deep context, which is exactly the profile AI systems are increasingly able to match.

The early results are specific enough to be instructive. Amazon's internal use of Q Developer to migrate tens of thousands of production applications from Java 8 to Java 17 saved more than 4,500 developer-years and produced $260 million in annual performance improvements, with individual transformations completing in an average of 15 minutes at a 99.7% success rate.

Architecture extraction addresses the trapped-value problem directly. IBM's watsonx Code Assistant for Z scans an entire application, builds a structural model of it, and isolates components for conversion, then validates translated code by running identical inputs through the original and the new implementation and comparing outputs. The undocumented becomes documented. The pricing logic, the risk model, the compliance rule, all become things that can be inspected and extended rather than just preserved.

The Scale of What's Waiting

According to Reuters, 220 billion lines of COBOL remain in active production use, handling $3 trillion in daily commerce and underpinning 43% of banking systems. Behind those numbers sits decades of underwriting decisions and fraud detection logic, encoded by people no longer there to explain why a given check exists. The same pattern repeats across insurance, healthcare, and government.

The workforce dimension is accelerating the timeline. IBM Research notes that fewer COBOL engineers exist each year, which means fewer people left who can explain what these systems are actually doing. The knowledge gets harder to recover the longer organizations wait.

The legacy modernization market currently sits at roughly $25 billion and is projected to reach $66 billion by 2031, a 17% compound annual growth rate. That reflects more than technical debt anxiety. It reflects growing recognition that the logic inside these systems is worth recovering, not just maintaining.

The Factory Floor's Largest Workload

Internal developer portals, golden paths, and pipeline-embedded governance all assume the software running through them was built recently enough to be legible. Legacy systems predate those conventions entirely.

Migration is how decades of trapped business logic becomes platform-native, accessible to the governance and automated oversight that AI-assisted development requires. An organization can't fully industrialize its software production while its most valuable institutional knowledge stays opaque and unobservable.

The factory floor has an intake problem. Legacy systems are the backlog, and the backlog is enormous.

Closing

Migration doesn't get easy. The failure mode changes. AI-assisted migration lets you characterize a system comprehensively before committing to a transformation path, then validate behavior incrementally against the original system's outputs. That's a structurally different kind of project than the bet-the-company migrations of the past, one where the goal is recovery, not just survival.

The pressure to act is increasing independent of the tooling. Cloud vendors are accelerating end-of-life timelines. Regulatory requirements around auditability are tightening. Gartner projects that by 2027, generative AI tools will cut legacy modernization costs by 70%.

The enterprises that move first won't just be modernizing infrastructure. They'll be converting their most valuable institutional knowledge into something that can be governed, audited, and extended. That has always been the actual prize. The value was never the COBOL or the mainframe. It was the decades of business logic those systems happened to be the only place holding.

What happens when that logic gets translated, the new code ships faster than ever, and the governance systems meant to keep it safe can't keep up? The next essay takes that question on directly.

Next in the series: "Vibe Coding Has a Governance Problem" — How AI-generated code is creating security vulnerabilities, dependency sprawl, and architectural drift faster than most engineering organizations can detect them, and what governance-first development has to look like instead.