How LLMs Could Help Migrate Legacy Systems

Legacy code modernization has moved from a periodic IT project to a continuous engineering discipline — driven by cloud migration deadlines, cybersecurity mandates, memory-safety requirements, and the growing shortage of engineers who can maintain COBOL, VB6, and mainframe assembler. The dramatic advance in AI coding capabilities since 2023 has fundamentally changed the economics of these projects. In 2026, agentic code assistants (Claude Code, Cursor Composer, Aider, Devin, OpenHands) can autonomously execute multi-step migration workflows that would previously have taken weeks of manual engineering.

Foundation models like GPT-5, Claude Opus 4, and DeepSeek Coder — plus specialized migration tools from IBM, AWS, and Google — have made legacy modernization measurably faster, cheaper, and less risky than it was even 12 months ago. This article explores where AI genuinely helps, where it doesn’t, and how enterprise teams are actually using LLMs for legacy migration in 2026.

LLM in Legacy Code Migration: Key Insights

• Legacy migrations remain complex, risky, and costly — but AI has fundamentally changed the economics. Projects that took 18 months in 2023 can often be delivered in 4–8 months in 2026 with the right AI tooling.
• The dominant LLMs for code work in 2026 are Claude Opus 4 (currently leads SWE-bench Verified at 70%+), GPT-5, and DeepSeek Coder — combined with specialized migration platforms like IBM watsonx Code Assistant for Z, Amazon Q Code Transformation, and Google Gemini Code Assist.
• Agentic code assistants — Claude Code, Cursor Composer, Aider, Devin, OpenHands — have moved beyond code completion to autonomously executing multi-step migration workflows: reading a legacy repo, generating documentation, translating modules, writing tests, and iterating until tests pass.
• Human oversight remains essential, especially for edge cases, domain-specific business logic, security-critical code, and validation. AI accelerates the work; it doesn’t eliminate the engineering judgment required.
• Regulatory and compliance context matters. The EU AI Act, sectoral rules (HIPAA, DORA, PCI DSS), and increasing pressure for memory-safe languages (Rust, especially in critical infrastructure) shape both what gets migrated and how AI-generated code must be reviewed.
• The 2026 modernization pipeline is AI-augmented, not AI-replaced — combining agentic code tools, specialized migration platforms, MLOps-style evaluation, and human review at every meaningful gate.

The Challenges and Costs of Legacy Code Migration

Migrating legacy codebases is a complex and costly endeavor – one that continues to burden organizations striving to modernize their IT infrastructure. Legacy systems often rely on outdated technologies, monolithic architectures, and aging development practices, making them difficult to understand, maintain, and integrate with modern platforms.

The common pain points include:

• Complexity
  Legacy code is frequently poorly documented, tightly coupled, and built on obsolete frameworks, all of which significantly complicate reverse engineering and migration planning.
• Risk
  Any modification to legacy systems can introduce unintended bugs or outages, posing a serious threat to business continuity and service availability.
• Time and Cost
  Manual migration requires considerable effort, domain expertise, and cross-functional coordination – often stretching project timelines and inflating budgets. According to Oracle, over 80% of data migration projects fail to meet their deadlines or remain within budget, largely due to these inherent complexities.¹
• Compatibility Issues
  Legacy applications may use proprietary standards, deprecated libraries, or unsupported protocols, making them fundamentally incompatible with modern infrastructure and requiring extensive code rewrites or architectural refactoring.⁶
• Data Integrity and Downtime Risks
  Migrating large volumes of production data without loss, duplication, or corruption remains a high-stakes challenge. Additionally, prolonged downtime during the transition can severely impact operational performance and customer experience.²

Despite these challenges, the business drivers for modernization are compelling: improving agility, strengthening security, ensuring regulatory compliance, reducing technical debt, and enabling seamless integration with cloud-native, API-driven, and distributed architectures.

Introducing LLMs as a Powerful Migration Tool

Modern Large Language Models — including Claude Opus 4 (Anthropic), GPT-5 (OpenAI), Gemini 2.5 Pro (Google), DeepSeek Coder V3, and Qwen2.5-Coder — have emerged as fundamental tools for legacy code migration. Claude Opus 4 currently leads SWE-bench Verified (the industry-standard benchmark for real-world software engineering tasks) at over 70%, compared to ~13% at the time GPT-4 was released. Alongside these general-purpose foundation models, specialized migration platforms have matured rapidly:

• IBM watsonx Code Assistant for Z — targeted specifically at COBOL and mainframe modernization
• Amazon Q Code Transformation — automates Java version upgrades (e.g., Java 8 → Java 21) and .NET Framework → .NET migrations at enterprise scale
• Google Gemini Code Assist — integrated code migration and modernization across Google Cloud environments
• GitHub Copilot Modernization — coordinated legacy code migration inside GitHub Enterprise

Together, these tools bring a new layer of intelligence to modernization efforts:

Understanding and analyzing code: LLMs can parse complex, poorly documented legacy codebases, infer business logic, and generate missing or outdated documentation—bridging knowledge gaps that often stall migration initiatives.

Translating code across languages and frameworks: These models are capable of converting legacy code written in older languages like COBOL, VB6, or C++ into modern programming languages such as Java, C#, or Python. Importantly, they can adapt the output to reflect current development standards and architectural best practices.⁵

Comprehending code context: Unlike basic syntax converters, LLMs understand surrounding context—including variable usage, control flow, and external dependencies—enabling more accurate, maintainable, and meaningful code translation that preserves business functionality.

By automating and augmenting traditionally manual, error-prone tasks, LLMs are redefining what’s possible in modernization timelines, accuracy, and scalability.

Agentic Code Assistants: The 2026 Shift

The biggest change in AI-assisted code migration since this article was first written is the emergence of agentic code assistants — tools that don’t just suggest code but autonomously execute multi-step engineering workflows.

Where GitHub Copilot in 2022 offered next-line autocompletion, tools in 2026 read entire repositories, plan migrations, execute changes across dozens of files, run tests, iterate on failures, and submit pull requests for human review — all from a single natural-language instruction like “migrate the auth module from VB6 to modern C# following our team conventions.”
The leading agentic code tools in 2026:

• Claude Code (Anthropic) — command-line agent optimized for complex, multi-file engineering tasks; strong performance on legacy code understanding
• Cursor Composer — IDE-integrated agent that operates across an entire codebase with human approval gates
• Aider — open-source terminal-based coding agent, widely used for automated migration and refactoring
• Devin (Cognition) — autonomous software engineer targeted at end-to-end task completion
• OpenHands (formerly OpenDevin) — open-source alternative to Devin
• GitHub Copilot Workspace — agent workflow inside the GitHub interface

For legacy migration specifically, agentic tools change the workflow from “prompt the LLM for one function translation at a time” to “give the agent the source module and target framework, review its plan, and iterate on its pull requests.” This shift is what makes multi-month migrations tractable for engineering teams that couldn’t otherwise justify the cost.
Important caveat: agentic code migration still requires rigorous human review, robust test coverage before starting, and explicit approval gates for high-stakes changes. Agents can silently introduce subtle bugs — particularly in domain-specific business logic, edge cases, and security-critical paths — that automated tests won’t catch. The 2026 best practice is treating agentic code work as a very fast, very productive engineer whose work must still be reviewed like any other engineer’s.

Potential Use Cases for LLMs in Code Migration

Large Language Models (LLMs) are proving to be versatile assets in legacy modernization initiatives, offering support across a wide range of tasks that have traditionally required intensive manual effort. Their utility spans from initial code comprehension to post-migration validation, making them a valuable co-pilot throughout the transformation journey.

One of the most impactful applications is in code understanding and documentation generation. Many legacy systems suffer from a lack of up-to-date documentation, making onboarding and refactoring extremely difficult. LLMs can analyze these codebases and generate accurate, human-readable summaries, inline comments, and architectural overviews, bridging the gap between tribal knowledge and maintainable design. This accelerates team understanding and de-risks the migration planning phase.

LLMs also enable automated code translation and intelligent refactoring. Unlike traditional transpilers that perform one-to-one syntax mapping, LLMs understand business intent and design patterns embedded in the code. They can not only rewrite applications from legacy languages like COBOL, Perl, or VB6 into modern equivalents such as Python, Java, or TypeScript, but also restructure the output to follow modular, maintainable architectures aligned with modern software engineering principles.

Another critical use case lies in identifying compatibility and architectural issues. LLMs can flag deprecated APIs, unsupported libraries, and architectural constructs that are incompatible with target environments—such as containerized infrastructure, microservices, or serverless platforms. This early-stage insight reduces surprises during deployment and minimizes the need for last-minute architectural workarounds.

Finally, LLMs can significantly enhance test coverage during migration. By generating targeted unit tests and integration test scaffolds for the refactored code, LLMs help ensure functional equivalence with the legacy system and reduce the risk of regressions. These tests serve as a quality gate and confidence booster, especially in large-scale migrations where manual testing alone is insufficient or cost-prohibitive.

Collectively, these use cases illustrate that LLMs are not simply code converters—they are intelligent enablers that augment developer workflows, reduce risk, and accelerate time-to-value in modernization projects.

Benefits and Considerations of LLM-Assisted Migration

Integrating Large Language Models into legacy code migration initiatives offers a range of compelling benefits. First and foremost is speed: by automating key aspects of translation, refactoring, and documentation generation, LLMs can significantly compress project timelines that would otherwise stretch into months or years. What traditionally required weeks of manual effort—such as reviewing obsolete code, untangling undocumented logic, or rewriting to meet modern syntax—can now be accelerated through AI-assisted workflows.

In parallel, this reduction in manual effort allows engineering teams to reallocate their time and expertise toward more strategic activities. Instead of performing tedious, repetitive tasks, developers and architects can focus on system design, validation, and integration – areas where human judgment is essential and where LLMs act as powerful enablers rather than replacements.

Moreover, LLMs contribute directly to code quality during the migration process. By enforcing modern coding standards, generating inline documentation, and scaffolding test cases, these models help ensure that the modernized codebase is not only functional but maintainable and aligned with contemporary best practices. This mitigates the risk of recreating legacy problems in a new language or framework.

That said, successful adoption requires acknowledging and planning for key considerations. One primary concern is accuracy. While LLMs are remarkably capable, they may struggle with edge cases, deeply entangled business logic, or domain-specific patterns that were never documented or standardized. As a result, human oversight remains essential – especially during validation and integration phases.

Equally important is the need for strategic project planning. LLMs are not a silver bullet; their use must be embedded within a broader modernization strategy that includes robust version control, test coverage, stakeholder alignment, and risk mitigation practices. Without a clear roadmap and cross-functional coordination, even AI-assisted efforts can falter.

Finally, security and compliance must be front and center. Migrating legacy code presents a unique opportunity to modernize not just language but posture. With increasing emphasis on memory-safe languages like Rust, especially in regulated industries, organizations must critically assess whether LLM-generated code meets evolving security and compliance standards. Furthermore, when using AI models – especially in hosted environments – data privacy, IP protection, and model provenance must be taken into account.

The regulatory environment adds another layer to AI-assisted migration planning. The EU AI Act (in force since August 2024) doesn’t directly regulate coding assistants, but it does affect how the resulting systems can be deployed — particularly if they support decisions in HR, credit, healthcare, or law enforcement (all “high-risk” categories). DORA (EU financial services), HIPAA (US healthcare), PCI DSS (payments), and sectoral cybersecurity mandates increasingly require documented change control, traceability, and human oversight for code changes. AI-assisted migration doesn’t remove these obligations — it typically requires more rigorous documentation of what the AI produced, what a human reviewed, and what was tested. Enterprise teams that treat compliance as a Phase 1 concern (audit trails, code review logs, test evidence) rather than a Phase 5 retrofit avoid substantial rework at deployment time.

In short, while LLMs can supercharge modernization efforts, realizing their full value requires thoughtful integration into engineering workflows, project governance, and compliance frameworks.

Enterprise Case Studies: AI-Assisted Legacy Migration in Practice

Public case studies from major enterprises illustrate what’s achievable — and what still requires care — with AI-assisted migration:

• Amazon (Java migration). Amazon publicly reported using Amazon Q Code Transformation to migrate thousands of internal applications from older Java versions to Java 17, estimating hundreds of millions of dollars in engineering time savings annually. The pattern: agent-driven bulk migration of routine version upgrades, with human review focused on business-critical services and edge cases.
• IBM (COBOL modernization). IBM’s watsonx Code Assistant for Z specifically targets one of the highest-value legacy migration challenges: COBOL-to-Java translation for mainframe workloads. IBM’s documented approach combines LLM-based translation with domain-specific fine-tuning on COBOL patterns — recognizing that generic LLMs struggle with the specific idioms and edge cases of mainframe code.
• Financial services and healthcare (VB6 and mainframe migrations). While less publicly documented due to competitive sensitivity, banks and healthcare organizations have been using combinations of Claude Code, GitHub Copilot Modernization, and specialized platforms to accelerate long-standing VB6-to-.NET and mainframe migration projects. The typical pattern is agent-driven initial translation, followed by mandatory human review focused on regulated business logic and compliance-critical paths.

What these cases have in common:

• Success comes from scoped, well-defined migrations (a specific language version upgrade, a specific module family) — not “modernize the entire mainframe with AI.”
• Test coverage before starting is a gating condition. Without tests, AI-generated migrations can pass syntax checks while breaking business logic.
• Human review focused on high-stakes paths — regulated business logic, security-critical code, and edge cases — remains essential.
• Agent-driven workflows are fast at scale, making them particularly valuable for large, repetitive migration tasks (thousands of files, multiple repositories).

The Future of Legacy Modernization with AI

As AI capabilities continue to mature, the role of Large Language Models in legacy modernization is poised to expand significantly. Future LLM-powered tools will likely become deeply embedded within integrated development environments (IDEs), offering engineers real-time migration suggestions, automated refactoring, and intelligent prompts that adapt to the structure and context of the codebase. These systems will also evolve through continuous learning, leveraging insights from past migrations to improve accuracy, reduce hallucinations, and better accommodate industry-specific architectural patterns and compliance needs.

Perhaps most transformative, LLMs will help shape end-to-end modernization pipelines—orchestrating code analysis, translation, documentation, test generation, and even deployment workflows, all under human oversight. This holistic approach will reduce migration complexity and democratize modernization, making it viable for a broader range of teams and organizations.

Ultimately, this evolution will make legacy modernization not only faster and more cost-effective, but also more strategic—unlocking the full value of long-standing software investments while accelerating the shift toward agile, secure, and cloud-native architectures.

References

• [1] Anthropic. Claude Code documentation. URL: https://docs.claude.com/en/docs/claude-code/overview. Accessed April 03, 2026
• [2] Anthropic. Claude Opus 4 model card and SWE-bench performance. URL: https://www.anthropic.com/news. Accessed April 03, 2026
• [3] Amazon Web Services. Amazon Q Code Transformation. URL: https://aws.amazon.com/q/developer/transform/. Accessed April 03, 2026
• [4] IBM. watsonx Code Assistant for Z. URL: https://www.ibm.com/products/watsonx-code-assistant-z. Accessed April 03, 2026
• [5] GitHub. GitHub Copilot and enterprise modernization. URL: https://github.com/features/copilot. Accessed April 03, 2026
• [6] SWE-bench. Verified Leaderboard. (Industry-standard benchmark for real-world software engineering tasks.) URL: https://www.swebench.com/. Accessed April 03, 2026
• [7] McKinsey & Company. Legacy modernization and technology transformation. URL: https://www.mckinsey.com/capabilities/mckinsey-digital/our-insights. Accessed April 03, 2026
• [8] European Commission. EU Artificial Intelligence Act. URL: https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai. Accessed April 03, 2026