by Dmitri Kaznachey
Large language models (LLMs) offer a compelling way to accelerate the modernization of complex legacy systems. While LLMs can expedite code analysis and translation, they can miss dependencies, side effects, control flow, and business rules while producing convincing results [1]. A disciplined approach is required to integrate AI throughout the software development lifecycle (SDLC). This includes documenting legacy behavior, supporting code translation, and building a comprehensive test suite.
[1] https://actuary.eu/wp-content/uploads/2025/03/TEA41-Leveraging-LLMs-for-Code-Conversion-in-Finance.pdf
AI-assisted modernization relies on four reinforcing capabilities: governance that defines acceptable use and oversight, enhanced development practices that incorporate AI into the SDLC, controls that ensure that practices are followed, and engineering tools that make these practices repeatable.
Controls and tools must be carefully calibrated. Weak controls can let errors go undetected. For example, skipping code review during legacy-code translation can leave defects undetected and limit the team’s understanding of the modernized code, increasing implementation and maintenance risk [2].
On the other hand, overly restrictive controls can erase AI’s speed advantage. Fully manual reviews may eliminate expected productivity gains. AI agents can help by auditing generated code, preparing reviewer notes, and interacting with source-code repositories and development tools. Teams must strike the same balance across requirements, test coverage, code check-ins, and performance testing. Organizations can develop this capability through experimentation, but experienced coaching can accelerate progress by providing an initial operating model, engineering tools, and a path for turning lessons learned into a repeatable lifecycle.
Human expertise remains essential. While AI can interpret and translate legacy code, business and engineering professionals must validate business rules, regulatory requirements, architecture, testing, performance, and quality.
[2] https://www.geoffreylitt.com/2026/07/02/understanding-is-the-new-bottleneck
Consider a decades-old MATLAB mortgage pricing library containing hundreds of functions for prepayment, default, and term-structure models, along with pricing, risk, and cash flow calculations for mortgages, debt, and derivatives. Modernizing this library should be incremental. Each module moves through AI-assisted behavioral discovery, protection through tests, code translation, and output reconciliation. This process creates traceable evidence for evaluating behavioral differences and determining whether each module is ready for production.
Modernizing a platform of this scale with an AI-enhanced, disciplined approach has the potential to reduce a traditional multi-year modernization effort by as much as half while maintaining the same engineering rigor. Much of the work involves establishing effective processes and validating system behavior, not simply writing code. Once proven, this approach can inform future modernization projects and enhance broader software development practices.
The Takeaway: Handing legacy code to an LLM may produce convincing code quickly, but it does not guarantee equivalent behavior. Faster, safer modernization requires an AI-assisted software development lifecycle that combines governance, engineering discipline, fit-for-purpose tools, and expert judgment.
