What legacy system will you modernize next? Start building now with GitHub Copilot now >
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.
| 💡Pro tip: Always have human experts review AI-generated analysis. AI is incredible at pattern recognition, but domain knowledge still matters for business context. |
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 PurposeCustomer 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 systemStep 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.”
💡Pro tip: COBOL’s verbosity is actually an advantage here. Statements like ADD TOTAL-SALES TO ANNUAL-REVENUE are almost self-documenting. Ask Copilot to extract these business rules into natural language descriptions. |
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.
| 💡Pro tip: Use Mermaid diagrams to visualize complex dependencies before making any changes. It helps you catch edge cases early. You can generate these diagrams by asking Copilot to trace all CALL statements in your codebase and output them in Mermaid syntax. Mermaid chart example: |
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, JavaConverterAgentCost 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 quicklyTry running the COBOL modernization framework:
- Fork the repository: aka.ms/cobolSet up your environment: Configure Azure OpenAI endpoint (or use local models for sensitive data)Run the doctor script:
./doctor.sh doctor validates your setup and dependenciesStart modernization: ./doctor.sh run begins the automated process# Quick setup for the impatient developergit clone https://github.com/Azure-Samples/Legacy-Modernization-Agentscd Legacy-Modernization-Agents./doctor.sh setup./doctor.sh runThe 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 fileDocument what you discover in markdownShare findings with your team
Build your AI toolkit
- Experiment with the Azure Samples frameworkLearn 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 designPlan for distributed systems architectureRemember: 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:
- Generate business logic documentationIdentify potential modernization opportunitiesCreate 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.
The post How GitHub Copilot and AI agents are saving legacy systems appeared first on The GitHub Blog.
