5 Critical Lessons on Agentic Programming and Legacy Modernization

By

Last week, I participated in an off-the-record retreat where software professionals gathered to discuss how agentic programming is reshaping the industry. Under Chatham House Rule, I can't name names, but the insights were too valuable not to share. Here are five key takeaways that can help you navigate these turbulent times. Use the links below to jump to a specific insight.

1. LLMs Can Clone Entire Compilers in Days

One team managed to create a behavioral clone of the GNU Cobol compiler using Rust—all in just three days. The result: 70,000 lines of Rust, built almost entirely with the help of large language models. This demonstrates the raw power of LLMs to port existing codebases to new platforms rapidly. The success hinges on the quality of regression tests, which, in this case, were good enough to verify correctness. If you have a solid test suite, you can leverage LLMs to migrate legacy code far faster than traditional methods. This approach could revolutionize how we update aging systems, reducing months of manual translation to mere days. The key is to treat the LLM as an automated porter that needs robust validation guardrails.

5 Critical Lessons on Agentic Programming and Legacy Modernization
Source: martinfowler.com

2. Let an LLM Interrogate Your Experts for Spec Review

Large specification documents are notoriously difficult for humans to review. One attendee shared a clever workaround: use an LLM to interview a domain expert. Instead of a person reading through hundreds of pages, the LLM asks the expert targeted questions about correctness. Think of it as a Socratic dialogue with AI. The LLM probes inconsistencies, missing details, and edge cases that a human might overlook. This method—dubbed the Interrogatory LLM—transforms passive review into an active conversation. It's particularly effective for complex regulatory specs or system designs where every clause matters. The human expert's time is used efficiently, and the LLM ensures thorough coverage.

3. Change-Control Boards Are Your Organization's Memory

One seasoned consultant mentioned that their first step when entering an organization is to read the change-control board guidelines. Why? Because those guidelines are the scar tissue of everything that has gone wrong. Each rule, each process exists because something broke in the past. By understanding this documented history, you gain insight into the organization's pain points, risk tolerance, and informal hierarchies. This is a powerful way to quickly learn the unspoken lessons that shaped the current technical landscape. It's a reminder that culture is often the shadow of past failures. So next time you join a new team, start with the change-control docs—they'll tell you more than any architecture diagram.

4. Reassess the "Lift and Shift" Strategy with AI in Mind

Traditionally, "lift and shift"—porting a legacy system to a new platform while keeping all features—has been frowned upon. It was seen as a missed opportunity to trim bloat; after all, the Standish Group reported that up to 50% of features in old systems are unused. But LLMs change the calculus. With the ability to automatically translate code, the cost of lift and shift has plummeted. One attendee now advocates making it the first step in any legacy modernization. The reasoning: getting onto a modern platform (even with all the old features) unlocks better tooling, CI/CD, and observability. From there, you can iteratively cut unused features and refactor. Just don't stop after the initial port—use the new environment to evolve.

5. Financial Firms Face Unique Challenges—and Opportunities

Several attendees worked in finance, bringing tales of tangled legacy systems, strict regulatory controls, and extreme risk aversion. One misstep with money-moving software can lead to millions in losses or compliance penalties. Here, LLMs offer a double-edged sword. On one hand, automated porting (as seen in insight #1) can help modernize core banking platforms. On the other, regulatory scrutiny demands impeccable traceability and testing. The attendees emphasized that lifting legacy code to a new platform must be accompanied by a full regression suite and documentation of the transformation process. The financial sector is likely to be an early adopter of these techniques, precisely because the stakes are high and the potential savings enormous.

Conclusion: The rise of agentic programming is forcing us to reconsider long-held assumptions about software maintenance, specification review, organizational learning, and migration strategies. The retreat made clear that those who embrace LLMs as collaborative tools—not just code generators—will lead the change. From cloning compilers in days to having AI interview experts, these five lessons offer a practical roadmap. The future belongs to teams that combine human judgment with machine efficiency, learning from the past while boldly porting it to better platforms.

Tags:

Related Articles

Recommended

Discover More

Docs.rs Shifts Default: Fewer Build Targets AheadA Complete Guide to the Repair Tool in Subnautica 2: How to Find and Use ItLinux News Roundup: AI in Ubuntu, New Projects Folder, and Open Source MilestonesLessons in Scaling Multi-Agent Systems: A Shopify Case StudyCrimson Desert's Latest Patch: Rematch Bosses, Reclaim Territories, and Discover Legendary Pets