Using Claude Code for legacy modernization - 90 days does not finish it, but proves it is possible

Ninety days will not modernize your legacy COBOL system.

I need to say that upfront, and honestly, I find it increasingly frustrating that the tech industry keeps selling transformation on timelines that don’t hold up. Vendors pitch 90-day migrations. Consultants promise complete rewrites by Q3. And then, quietly, projects stall, budgets evaporate, and everyone pretends it never happened.

But what 90 days can do is this: prove that modernization is possible, show your organization what the path looks like, and build the momentum you’ll need for the real work ahead.

That distinction matters more than most people realize.

What actually happens in successful modernizations

Utah’s Office of Recovery Services transformed their 25-year-old COBOL application to Java on public cloud in 18 months. Lincoln Financial Group transitioned legacy COBOL and assembler code to cloud in 2 years.

Both are success stories. Not cautionary tales.

What made them work? They set realistic timelines and proved value incrementally. They didn’t promise complete transformation in 90 days. They used 90-day sprints to show progress and justify continued investment.

Organizations waste substantial resources annually on legacy inefficiencies, and leadership knows it. They’re desperate for solutions. But desperation is exactly when people buy impossible promises. That’s how projects get approved on bad timelines and die six months later.

The Standish Group’s CHAOS data shows that roughly two-thirds of technology projects end in partial or total failure. Large mainframe overhauls do even worse and take 3-5 years. The pattern is always the same: leadership approves the initiative, someone promises completion in an impossible timeline, early milestones get missed, budget overruns start, political will erodes. The project gets shelved. Nobody mentions it again.

The organizations that succeed plan for years but prove value every 90 days. That’s a fundamentally different mindset.

Where AI tools actually move the needle

AWS Transform modernized 40 million lines of COBOL for Toyota Motor North America 50% faster than traditional approaches. Real acceleration. But notice what it accelerated: a structured modernization program, not a chaotic 90-day sprint.

Tools like Claude Code bring three things to legacy work that genuinely change the math.

Code analysis and documentation. AI can read undocumented COBOL faster than any consultant. Claude Code handles context windows of up to 1 million tokens, giving it the capacity to analyze entire legacy modules in depth. That means it can analyze entire legacy modules in a single pass, map dependencies, identify business logic, and generate the documentation that probably never existed.

Pattern recognition across decades of code. Your COBOL system has patterns buried in millions of lines. AI finds them. Modern AI assistants can now sustain extended analysis sessions on complex tasks without losing coherence. This alone can save months of manual analysis.

Test generation from existing logic. Before you change anything, you need tests. AI can analyze what your code does and generate test cases that validate current behavior. Your developers already spend roughly 33% of their time dealing with technical debt. This safety net frees more of that time for actual modernization.

The current technical debt across U.S. organizations is staggering, consuming a significant share of IT budgets. I think the mistake most teams make is expecting AI to eliminate that debt in 90 days. It won’t. It gives you better tools to tackle it systematically.

The 90-day proof-of-concept that works

Most failed modernizations start by changing code before understanding it. Backwards.

When organizations spend 55% of their IT budgets maintaining outdated systems, leadership becomes receptive to alternatives. But they need proof the alternative works before committing fully. That proof has to come from somewhere real.

The Utah ORS project succeeded partly because they used automated refactoring tools that understood the complete system before touching anything. They mapped dependencies first, transformed code second.

Understanding before changing isn’t wasted time. It’s the difference between successful transformation and expensive failure. Modern AI tools can analyze codebases thousands of times faster than manual review. That doesn’t mean you skip the analysis. It means you do thorough analysis in weeks instead of years.

Pick your most painful COBOL module. The one where every change takes weeks because nobody understands it anymore. That’s your target.

Days 1-30: Map everything. Use AI to document the component fully. Every dependency, every business rule, every integration point. Build the test suite that validates current behavior. Financial services firms spend 70-75% of IT budgets on legacy COBOL platforms. If that’s your situation, this mapping phase will surface exactly what you’re dealing with.

Days 31-60: Transform the component. This is where AI-assisted code transformation happens. Not automatic conversion, which rarely works well. Assisted transformation, where AI suggests modern equivalents and developers validate the business logic. Modern tools include checkpointing features that let you save states and roll back changes, enabling risk-free experimentation. Anthropic’s own testing shows code editing error rates dropping dramatically with recent model improvements.

Days 61-90: Deploy and prove it. Get your modernized component working in production alongside the legacy system. Is there risk? Yes. That’s why you started with one non-critical component. Prove it handles real load. Show stakeholders the new code is faster and cheaper to maintain.

At day 90, you haven’t finished. You’ve proved it works. That proof is worth more than any presentation deck promising complete transformation.

Setting the team up to succeed

Three to five people who understand the legacy system and want to learn modern approaches. That’s your team. Not dozens. Small teams move faster, and this isn’t a project that benefits from headcount.

Choose a pilot component that’s painful but not mission-critical. Painful enough that success matters to the business. Not so critical that a misstep endangers operations. There’s a real sweet spot, and it’s worth spending time finding it before you start.

Use AI for acceleration, not automation. Modern AI-assisted approaches run 40-50% faster than manual work while maintaining quality, but developers still make the final calls on business logic. That hybrid model is the one that holds up.

Measure and communicate progress weekly. Show leadership real metrics: lines of code analyzed, tests generated, components modernized, performance improvements. Make progress visible and concrete.

Deploy incrementally. Don’t wait 90 days to deploy. Get your modernized component into production by day 60. Spend the final 30 days proving it works under real load. Then you walk into the funding conversation for phase two with evidence, not promises.

Planning the 18 months that follow

Successful modernization is a series of 90-day sprints. Not one massive project.

After proving the approach works on one component, you tackle larger ones with organizational confidence behind you. But probably the most important thing you can do at the start is reset expectations: this will take 18-24 months of sustained effort. Budget for it. Plan milestones that each deliver production value. Build the political capital to see it through.

The AWS Transform work on Toyota’s COBOL migration is impressive. But the story isn’t “AI finished it in 90 days.” The story is “AI cut the time of a multi-year program roughly in half.” That’s the honest framing you should use with your leadership team.

The organizations that successfully modernize legacy systems share one characteristic. They’re honest about timelines while aggressive about demonstrating value. Every 90 days, they ship something real. Every 90 days, they earn the right to continue.

I got this wrong early on. I used to think the hard part was the technical migration. It’s not. The hard part is earning organizational patience for a multi-year effort. Ninety days proves modernization works. The following 12-18 months complete it. Pick one painful component, use AI to accelerate the analysis and transformation, deploy to production, and use that win to fund what comes next.