How GitHub Copilot and AI agents are saving legacy systems

Picture this: you’re a developer in 2025, and your company just told you they need to modernize a mainframe system that processes millions of ATM transactions daily. We’re talking about COBOL, a programming language that’s been around for 65 years. That’s older than the internet.

Now, your first instinct might be to laugh or maybe cry a little. But here’s the thing—COBOL isn’t going anywhere. In fact, it’s powering some of the largest and most critical systems on the planet right now.

The problem? Finding developers who understand COBOL is like finding unicorns. The original developers are retiring, and yet 200 billion lines of COBOL code are still running our banks, insurance companies, and government systems.

But here’s the plot twist: we now have the opportunity to support the unicorns. We have GitHub Copilot and autonomous AI agents.

Meet the developer who’s modernizing COBOL (without learning COBOL)

I recently spoke with Julia Kordick, Microsoft Global Black Belt, who’s modernizing COBOL systems using AI. What’s remarkable? She never learned COBOL.

Julia brought her AI expertise and worked directly with the people who had decades of domain knowledge. That partnership is the key insight here. She didn’t need to become a COBOL expert. Instead, she focused on what she does best: designing intelligent solutions. The COBOL experts provided the legacy system knowledge.

When this whole idea of Gen AI appeared, we were thinking about how we can actually use AI to solve this problem that has not been really solved yet.

Julia Kordick, Microsoft Global Black Belt

The three-step framework for AI-powered legacy modernization

Julia and her team at Microsoft have cracked the code (pun intended) with a systematic approach that works for any legacy modernization project, not just COBOL. Here’s their GitHub Copilot powered, battle-tested framework.

Step 1: Code preparation (reverse engineering)

The biggest problem with legacy systems? Organizations have no idea what their code actually does anymore. They use it, they depend on it, but understanding it? That’s another story.

This is where GitHub Copilot becomes your archaeological tool. Instead of hiring consultants to spend months analyzing code, you can use AI to:

• Extract business logic from legacy files.
• Document everything in markdown for human review.
• Automatically identify call chains and dependencies.
• Clean up irrelevant comments and historical logs.
• Add additional information as comments where needed.

Here’s what GitHub Copilot generates for you: 

# Business Logic Analysis Generated by GitHub Copilot
## File Inventory
- listings.cobol: List management functionality (~100 lines)
- mainframe-example.cobol: Full mainframe program (~10K lines, high complexity)

## Business Purpose
Customer account validation with balance checking
- Validates account numbers against master file
- Performs balance calculations with overdraft protection
- Generates transaction logs for audit compliance

## Dependencies Discovered
- DB2 database connections via SQLCA
- External validation service calls
- Legacy print queue system

Step 2: Enrichment (making code AI-digestible)

You usually need to add context to help AI understand your code better. Here’s what that looks like:

Translation: If your code has Danish, German, or other non-English comments, translate them. Models work better with English context.

Structural analysis: COBOL has deterministic patterns. Even if you’ve never written COBOL, you can leverage these patterns because they’re predictable. Here’s how:

COBOL programs always follow the same four-division structure:

• IDENTIFICATION DIVISION (metadata about the program)
• ENVIRONMENT DIVISION (file and system configurations)
• DATA DIVISION (variable declarations and data structures)
• PROCEDURE DIVISION (the actual business logic)

Ask GitHub Copilot to map these divisions for you. Use prompts like:

"Identify all the divisions in this COBOL file and summarize what each one does"

"List all data structures defined in the DATA DIVISION and their purpose"

"Extract the main business logic flow from the PROCEDURE DIVISION"

The AI can parse these structured sections and explain them in plain English. You don’t need to understand COBOL syntax. You just need to know that COBOL’s rigid structure makes it easier for AI to analyze than more flexible languages.

Documentation as source of truth: Save everything AI generates as markdown files that become the primary reference. Julia explained it this way: “Everything that you let Copilot generate as a preparation, write it down as a markdown file so that it can actually reference these markdown files as source of truth.”

Step 3: Automation Aids (Scaling the Process)

Once you’ve analyzed and enriched individual files, you need to understand how they all fit together. This is where you move from using Copilot interactively to building automated workflows with AI agents.

Julia’s team built a framework using Microsoft Semantic Kernel, which orchestrates multiple specialized agents. Each agent has a specific job, and they work together to handle the complexity that would overwhelm a single AI call.

Here’s what this orchestration looks like in practice:

• Call chain mapping: Generate Mermaid diagrams showing how files interact. One agent reads your COBOL files, another traces the CALL statements between programs, and a third generates a visual diagram. You end up with a map of your entire system without manually tracing dependencies.
• Test-driven modernization: Extract business logic (agent 1), generate test cases that validate that logic (agent 2), then generate modern code that passes those tests (agent 3). The tests become your safety net during migration.
• Dependency optimization: Identify utility classes and libraries that you can replace with modern equivalents. An agent analyzes what third-party COBOL libraries you’re using, checks if modern alternatives exist, and flags opportunities to simplify your migration.

Think of it like this: Copilot in your IDE is a conversation. This framework is a production line. Each agent does one thing well, and the orchestration layer manages the workflow between them.

The reality check: It’s not a silver bullet

Julia’s brutally honest about limitations:

Everyone who’s currently promising you, ‘hey, I can solve all your mainframe problems with just one click’ is lying to you.

The reality is:

• Humans must stay in the loop for validation.
• Each COBOL codebase is unique and complex.
• We’re early in the agentic AI journey.
• Full automation is probably at least five years away.

But that doesn’t mean we can’t make massive progress today.

See it in action: the Azure samples framework

Julia and her team have open-sourced their entire framework. It’s built with Microsoft Semantic Kernel for agentic orchestration and includes:

• Multiple specialized agents: DependencyMapperAgent, COBOLAnalyzerAgent, JavaConverterAgent
• Cost tracking: See exactly how much each AI operation costs (usually $2-5 per 1000 lines analyzed)
• Human validation points: Built-in checkpoints for expert review
• doctor.sh: A configuration and testing script that gets you started quickly

Try running the COBOL modernization framework:

1. Fork the repository: aka.ms/cobol
2. Set up your environment: Configure Azure OpenAI endpoint (or use local models for sensitive data)
3. Run the doctor script: ./doctor.sh doctor validates your setup and dependencies
4. Start modernization: ./doctor.sh run begins the automated process

# Quick setup for the impatient developer

git clone https://github.com/Azure-Samples/Legacy-Modernization-Agents

cd Legacy-Modernization-Agents

./doctor.sh setup

./doctor.sh run

The business case that changes everything

This isn’t just about technical debt. It’s about business survival. Organizations are facing a critical shortage of COBOL expertise right when they need it most.

The traditional approach has been to hire expensive consultants, spend 5+ years on manual conversion, and end up with auto-generated code that’s unmaintainable. I’ve seen this play out at multiple organizations. The consultants come in, run automated conversion tools, hand over thousands of lines of generated code, and leave. Then the internal team is stuck maintaining code they don’t understand in a language they’re still learning.

The AI-powered approach changes this. You use AI to understand business logic, generate human-readable modern code, and maintain control of your intellectual property. Your team stays involved throughout the process. They learn the business logic as they go. The code that comes out the other end is something your developers can actually work with.

Julia explained the shift:

What a lot of customers do not want to actually give all their intellectual property like a hundred percent to a partner anymore, right? They want to keep it in check.

Start here: your path to becoming the modernization hero

Whether you’re dealing with COBOL, ancient Java, or any legacy system, here’s how you can start today:

Start small

• Identify one problematic legacy system (start with fewer than 5,000 lines)
• Use GitHub Copilot to analyze a single file
• Document what you discover in markdown
• Share findings with your team

Build your AI toolkit

• Experiment with the Azure Samples framework
• Learn prompt engineering for code analysis (try: “Analyze this COBOL program and explain its business purpose in simple terms”)
• Practice iterative modernization techniques

Think beyond code

• Consider nonfunctional requirements for cloud-native design
• Plan for distributed systems architecture
• Remember: most COBOL programs are doing simple CRUD operations. They don’t need the complexity of a mainframe. They need the simplicity of modern architecture.

Here’s a challenge: Find a legacy system in your organization. Six-month-old code counts as legacy in our industry. Try using GitHub Copilot to:

1. Generate business logic documentation
2. Identify potential modernization opportunities
3. Create a migration plan with human validation checkpoints

Share your results on LinkedIn and tag me. I’d love to see what you discover.

The best time to start is now

The most powerful insight from my conversation with Julia is this: AI doesn’t replace developer expertise. It amplifies it.

COBOL experts bring irreplaceable domain knowledge. Modern developers bring fresh perspectives on architecture and best practices. AI brings pattern recognition and translation capabilities at scale.

When these three forces work together, legacy modernization transforms from an impossible challenge into an achievable project.

The best time to modernize legacy code was 10 years ago. The second-best time is now.

Special thanks to Julia Kordick, Microsoft Global Black Belt, who shared her insights and experiences that made this blog post possible.

Ready to dive deeper? Check out the full blog post about this project at aka.ms/cobol-blog and connect with Julia on LinkedIn for the latest updates.

The age of legacy code doesn’t have to be a barrier anymore. With the right AI tools and framework, even 65-year-old COBOL can become approachable, maintainable, and modern.

Written by

Andrea Griffiths

@AndreaGriffiths11

Andrea is a Senior Developer Advocate at GitHub with over a decade of experience in developer tools. She combines technical depth with a mission to make advanced technologies more accessible. After transitioning from Army service and construction management to software development, she brings a unique perspective to bridging complex engineering concepts with practical implementation. She lives in Florida with her Welsh partner, two sons, and two dogs, where she continues to drive innovation and support open source through GitHub's global initiatives. Find her online @alacolombiadev.