5 Insights from a Retreat on Agentic Programming and Legacy Modernization

Last week, I attended a retreat where software professionals gathered to discuss the impact of agentic programming on the future of development. Under the Chatham House Rule, I can't attribute specific comments, but I captured five standout ideas that reveal how AI is reshaping legacy code, specifications, and organizational habits. Let's dive in.

1. Rapid Code Porting with LLMs: From COBOL to Rust in Days

One team created a behavioral clone of the GNU COBOL compiler in Rust—70,000 lines of code built in just three days. This showcases LLMs' ability to port existing codebases efficiently to new platforms. The key enabler isn't just model power but robust regression tests. If you have a test suite that validates behavior, you can trust the port. Even without one, you might generate tests from an existing implementation. This shifts the economics of legacy migration dramatically.

2. Interrogatory LLMs: Let AI Interview Humans to Verify Specs

A large specification document is tough for a human to review completely. One attendee suggested turning the LLM into an interrogator: it asks an expert questions to validate each part of the spec. This interrogatory LLM catches gaps and inconsistencies early. Instead of reading line by line, the expert responds to queries, making the process faster and more thorough. It’s a clever way to combine human expertise with machine persistence.

3. Change-Control Boards as Organizational Scar Tissue

When consulting, one developer starts by reading the organization’s change-control board guidelines. Why? Because those rules are hardening of past failures—the “scar tissue” of what went wrong. Understanding that history explains why processes are the way they are. If you want to modernize, you must respect that wisdom. It’s a practical tip for anyone entering a legacy-heavy environment: learn the pain points first.

4. The Shift in Legacy Lift-and-Shift: From Missed Opportunity to First Step

Traditionally, “lift and shift” (porting a system with full feature parity) was seen as wasteful—especially since studies show up to 50% of features are unused. The better approach was to reimagine needs. But LLMs change the calculus. Now, lifting and shifting can be the first step, because the cost has plummeted. Once on a modern platform, further evolution becomes cheaper. The caveat: don’t stop there. Use the new environment to slim down features based on actual usage data.

5. Financial Sector Realities: Legacy, Regulation, and Risk

Several attendees from the financial industry highlighted the unique challenges: complex legacy code intertwined with regulatory constraints and high risk. When software handles money, errors are unacceptable. This creates a conservative culture where change is slow. Yet agentic programming offers paths—like automated regression testing and behavior-preserving transformations—that could help these organizations modernize without triggering compliance nightmares. The key is incremental, verifiable steps.

These five insights reflect a broader theme: the rise of agentic programming is changing how we think about software evolution. From code porting to specification verification, the tools are maturing quickly. The best strategies will combine these new capabilities with a deep understanding of organizational history and risk tolerance. As one attendee put it, “The cost of migration is no longer the barrier—the barrier is our willingness to start.”