Your Legacy Code Is AI's Best Job

🎯 Who this is for: IT leaders sitting on decades of COBOL, RPG, PL/I or Java 8, and the developers who've been told to "just keep it running."

Series: Part 6 of 13 — Enterprise Vibe Coding | Read time: 6 minutes

Every vibe coding demo looks the same. Someone types "build me a to-do app with dark mode," and ninety seconds later there's a to-do app with dark mode. The audience claps.

Now walk into a government IT department. There's a batch job written before most of the team was born. Its JCL calls a PL/I program that calls another program whose author retired in 2009. The documentation is a binder. The binder is wrong.

Nobody in that building needs a to-do app. They need someone — or something — to read that code, tell them what it actually does, and help them move it forward without breaking the tax run.

That's where AI coding earns its keep in the enterprise. Not the blank page. The old page.

🏚️ Where the Work Actually Is

IBM's Neel Sundaresan put a number on it at Think 2026: about 60% of work is migration, modernization and maintenance, while new code development is only about 15%.

You don't need to trust the exact split to recognise the shape. In a bank, a utility, an insurer or a manufacturer, most developers spend most of their week on systems that already exist. If AI only helps with greenfield work, it's helping with the smallest slice of the pie.

Legacy work also has a hidden advantage for AI: the old system defines "correct." When you upgrade a Java service, you know exactly what it should do — what it did yesterday. That gives you something to test against, which is far more than you get from a vague "build me a dashboard."

📖 Start With Reading, Not Writing

The safest, fastest win is not modernization. It's comprehension.

Ask an agent — in Ask mode, from Part 4 — to explain a module, map its dependencies, and write the documentation nobody ever wrote. Nothing changes in the codebase. Your senior engineers review the output and immediately learn two things: what the code does, and how far they can trust the AI on your code.

IBM-published customer stories lean on exactly this. APIS IT, which runs public-sector systems in Croatia, reports (via IBM) "10x faster architecture analysis and documentation" and "100% accuracy" documenting legacy JCL/PL/I, plus .NET service migrations done in hours instead of weeks.

💡 Key insight: Documentation is the perfect pilot. It's read-only, it's useful even if the AI never touches production code, and it builds the context file your agents will need later (more on that in Part 11). It also gives your experts a low-stakes way to grade the AI.

🔧 Then the Mechanical Upgrades

Once you trust the reading, the next tier is mechanical, well-bounded change: version upgrades, deprecated API replacements, dependency bumps. Tedious for humans; a good fit for agents.

The headline example is Blue Pearl, a South African cloud consultancy. In an IBM-published case study, they report turning a "typical 30-day Java upgrade" into 3 days with IBM Bob, saving 160+ hours with zero post-deploy defects. IBM's write-up says the work moved Java 11 to 21, resolved 127 deprecated API calls, and took test coverage from 0% to 92%. (Heads-up: IBM's own materials aren't fully consistent on the target Java version — some say Java 25. Small detail, but a reminder that marketing copy isn't a lab report.)

Legacy taskAI fitWatch out for
Explain & document old codeExcellent — read-only, low riskConfident but wrong explanations of obscure logic
Generate tests around existing behaviourVery goodTests that pass because they assert the bug
Version upgrades & deprecated APIsGood — bounded and testableSubtle behaviour changes between versions
Language translation (e.g. COBOL → Java)Promising, needs heavy reviewCode that compiles but loses business rules
Re-architecting a core systemAssistive onlyAnyone who says "the AI will do it"

Notice that Blue Pearl went from zero tests to 92%. That's the real lesson. Generate the safety net before you change anything. Tests that pin down today's behaviour are what make tomorrow's AI-driven change reviewable.

⚠️ The Honest Caveats

Legacy platforms are exactly where AI models have seen the least training data, and it shows.

  • IBM i users have reported Bob hallucinating CL command parameters — options that look plausible and don't exist.
  • Mainframe IBM Champion Uwe Graf noted Bob suggesting dated COBOL patterns, and flagged that the model choice was opaque.
  • All the impressive numbers above are IBM-reported or IBM-published. IDC said at Bob's GA that the "external evidence base remains limited." That's not a knock on the results — it's a reason to run your own pilot (Part 10).

Every vendor in this space — IBM with its Java, IBM i and Z packages, and the general-purpose tools like Copilot, Cursor, Claude Code and Kiro — will tell you legacy modernization is a sweet spot. They're probably right. But "sweet spot" means "highest return for careful work," not "press button, receive modern system."

🪜 A Sensible Path

  1. Document one gnarly module. Have your experts grade it.
  2. Generate tests that capture current behaviour. Review them hard.
  3. Upgrade something mechanical — a Java version, a library — in small steps, with Plan mode and approvals on.
  4. Measure honestly: hours, defects, reviewer time. Compare to a real baseline.
  5. Only then consider bigger translations or re-architecture.

Key Takeaways

  • Most enterprise effort — IBM estimates around 60% — is migration, modernization and maintenance, not new code.
  • Start read-only: documentation and architecture analysis are low-risk, high-value pilots.
  • Blue Pearl (30 days → 3) and APIS IT (10x faster documentation) are IBM-reported results — encouraging, not benchmarks.
  • Tests first. Pin current behaviour before letting an agent change it.
  • Expect hallucinations and dated patterns on older platforms; keep experts in the loop.

References

🧰 From TheMaximoGuys toolbox: Got legacy Maximo Java customizations? Max_autoscripts — open source (MIT) — ships 67 Jython samples, 28 templates and Java→Jython conversion guides, plus an AGENTS.md so Claude, Bob, Copilot or Cursor follow the same conversion rules your team does.

Series Navigation

Previous:Part 5 — Human-in-the-Loop Is a Feature
Next:Part 7 — Vibe Coding Behind the Firewall

Published by TheMaximoGuys | August 2026