For decades, enterprise IT has lived with an uncomfortable bargain: keep the mainframe-era systems running because they are reliable, business-critical—and painfully hard to replace. But a new wave of agentic coding tools is trying to break that bargain by making modernization less like a multi-year rewrite and more like an iterative, test-driven engineering program.
That’s the core argument in Anthropic’s The Code Modernization Playbook, a guide aimed at technical leaders responsible for aging stacks: rising maintenance overhead, scarce legacy-language talent, and mounting security risk. The playbook frames agentic tools—explicitly naming Claude Code—as a practical way to analyze large codebases, generate missing documentation and tests, and translate platforms while preserving business rules. Code Modernization Playbook
The modernization bottleneck has a number attached to it
One reason the playbook lands with engineering leaders is that it leans on a familiar reality: modern teams spend a non-trivial chunk of their week “servicing the past.” It cites McKinsey’s estimate that the average developer spends 17.3 hours per week dealing with technical debt and maintenance work instead of building. Code Modernization Playbook
The labor market adds pressure. Legacy expertise is getting harder to hire, and younger engineers often see COBOL and older Java stacks as career dead ends. At the same time, the playbook points to the huge installed base: the Open Mainframe Project’s COBOL Working Group estimated 250 billion lines of COBOL still in use (2021). Code Modernization Playbook
That combination—high dependency plus shrinking talent—has always helped incumbent ecosystems (including IBM-centric mainframe environments) retain a kind of “gravitational pull.” If maintaining the old system requires specialists, and replacing it requires even rarer specialists, many organizations simply don’t move.
Agentic tooling is designed to weaken that inertia.
Why this matters to IBM and the wider “legacy economy”
The playbook doesn’t name IBM as a target. But the implications are hard to miss for any vendor whose ecosystem benefits from legacy complexity: if agentic tools can reduce the cost and risk of migration, they can also reduce the “switching tax” that keeps customers anchored.
In other words, the disruptive vector isn’t that AI “kills” the mainframe overnight. It’s that AI changes the economics of moving off it—or of refactoring it into hybrid architectures where the old core shrinks over time.
Agentic coding is pitched as a way to do what many teams wish they could do, but rarely can: modernize without pausing feature delivery. Code Modernization Playbook
What “agentic” means in code modernization (beyond a chatbot)
The playbook draws a line between autocomplete-style assistance and agentic systems that can operate across a workflow: reading repositories, proposing plans, editing files, running commands, and iterating based on outputs—while maintaining guardrails like audit trails and role-based access controls. Code Modernization Playbook
It also highlights a technical “stack” behind the scenes: memory systems for long-running projects, function/tool capabilities for transformations, and the ability to connect tools via open standards like MCP (Model Context Protocol). Code Modernization Playbook
That detail matters for sysadmins and platform engineers, because it signals where the operational burden moves next: not just “which model,” but how the agent is governed, where it can execute, how actions are logged, and what it’s allowed to touch.
Real-world scenarios: what teams are actually modernizing
Instead of presenting modernization as a single monolithic migration, the playbook breaks it into repeatable use cases. Among the examples:
1) Language migration (COBOL → Java/Python/C#)
A sample scenario describes an insurance company migrating a COBOL claims processing system to Java after the agent analyzed architecture and uncovered hidden dependencies, while preserving business rules and adding modern patterns. Code Modernization Playbook
2) Platform modernization (batch → serverless, on-prem → Kubernetes)
Another scenario describes converting a mainframe inventory batch job into AWS Lambda functions in Python, moving from overnight processing toward real-time updates. Code Modernization Playbook
3) Architecture transformation (monolith → microservices)
A financial services example focuses on decomposing a monolith into services like order management and risk calculation after analyzing millions of lines of code for service boundaries and dependencies. Code Modernization Playbook
4) Integration modernization (FTP/file exchange → REST APIs)
A logistics example describes moving from FTP-based partner integrations to REST APIs, reducing integration errors and supporting real-time updates while maintaining backward-compatible workflows. Code Modernization Playbook
To many teams, none of this is new in theory. What’s new is the claim that agents can handle more of the “code archaeology” that usually eats months: mapping dependencies, extracting implicit business logic, and generating test suites that make migration safer.
A maturity model that reads like a roadmap
One of the more practical parts is a modernization maturity model that frames how organizations evolve:
| Maturity level | What it looks like in practice |
|---|---|
| Ad hoc | Modernization only during crises: retirements, outages, compliance deadlines. Minimal tests and documentation. |
| Planned | Annual projects exist, but siloed; politics can drive selection; limited ROI discipline. |
| Systematic | Dedicated teams, living inventories, standardized playbooks, automated testing for compatibility. |
| Optimized | Agents proactively propose modernization with ROI analysis; continuous refactoring and compliance updates. |
This ladder is less about aspiration and more about diagnosing what’s missing. The playbook’s subtext is blunt: if an organization is operating in “ad hoc,” it’s not choosing stability—it’s choosing a slow-motion failure mode.
Code Modernization Playbook
The “getting started” rule that will irritate (and help) managers
The guide offers a simple readiness signal: if teams spend more than 40% of their time on maintenance instead of delivering new features, modernization is likely to pay back quickly—especially if hiring for legacy skills is slow and expensive. Code Modernization Playbook
From there, it recommends a phased approach that starts with low-risk systems and uses early wins to build organizational confidence—while emphasizing something many companies skip: building validation capacity (tests/evals) before migrating anything critical. Code Modernization Playbook
That’s not glamorous, but it’s consistent with what breaks modernization projects in the real world: teams don’t fail because they can’t translate code; they fail because they can’t prove equivalence, manage edge cases, or maintain operational continuity.
The hidden battleground: governance, security, and auditability
For sysadmins and security teams, “agentic modernization” raises a predictable concern: if an AI can edit code and run commands, how do you prevent it from becoming a privileged automation hazard?
The playbook answers by leaning on governance primitives: transparent plans before changes, approval checkpoints, audit trails, and role-based access controls—plus integration with enterprise AI deployments (it cites cloud options such as Bedrock and Vertex AI). Code Modernization Playbook
In practice, this is where the conversation moves from “cool demo” to “can it pass an internal security review?”
A quieter disruption than layoffs—but potentially bigger
If agentic tools deliver even part of what they promise, the effect won’t look like a single “IBM moment.” It will look like thousands of decisions across enterprises: migrate one batch job; wrap one legacy interface; extract one undocumented rule set; retire one dependency. The compounding effect is what threatens the old equilibrium.
For IBM and other incumbents, the challenge is not that modernization suddenly becomes easy. It’s that modernization becomes plausible, more often, for more teams—because the first draft of the work (analysis, translation, tests, documentation) becomes cheaper to produce.
And in enterprise IT, plausibility is often the real trigger for change.
FAQs
What is agentic coding in legacy modernization?
Agentic coding refers to AI systems that can plan and execute multi-step development tasks—reading a large codebase, proposing changes, editing files, running commands/tests, and iterating—rather than only generating snippets or autocomplete suggestions. Code Modernization Playbook
Can AI really migrate COBOL systems without breaking business rules?
The playbook’s position is that agents can preserve business logic by analyzing architecture and dependencies and by generating test suites for equivalence checks—while humans still supervise and validate the migration.
What should sysadmins require before allowing agentic tools in production workflows?
At minimum: role-based access controls, auditable change logs, approval gates before modifications, and a clear boundary for where the agent can execute commands and access credentials. Code Modernization Playbook
How do you pick a “first modernization project” that won’t explode?
Start with a low-risk, high-visibility system (batch reporting, standalone calculation engines, peripheral integrations), then use the agent to document and test before attempting full cutover.