Legacy code modernization with AI

The Problem

At Blis Digital, we work on complex software challenges in our AI Lab every day. One of the most time-consuming and costly tasks we face as software developers is modernizing legacy code bases. Whether it's an outdated Xamarin.Forms app that needs to go to React Native, an old AngularJS application that needs to be migrated to modern frameworks, or an ASP.NET MVC system that needs to be migrated to Blazor — the challenge remains the same.

Legacy systems often include years of business logic, grown without a clear architecture, with little to no testing, and full of “God classes” that do it all. However, these systems run critical business processes and cannot simply be taken offline for a complete rebuild.

The traditional approach? Months of manual recoding, with huge risks of regressions and loss of functionality. This is not only expensive, but also error-prone and demotivating for development teams.

What is AI-driven legacy modernization? An innovative approach where AI analyses the functionality of existing code and helps generate modern applications. In our practice, this achieves 85-95% automation for standard features.

AI-Driven Modernization vs Traditional AST Methods

Before AI became mainstream, we tried to solve this problem with Abstract Syntax Trees (AST) and automated code transformations. The theory was simple:

We built platform-specific parsers, wrote complex transformation rules, and hoped that the output would be useful. Parallel to this, we worked with:

• Regression tests: Comprehensive test suites to validate functionality
• Shadow projects: New systems that were rebuilt bit by bit
• Incremental migration: Transfer module by module

Why This Was So Complex and Time-consuming

1. Parser Complexity: Each programming language and framework required its own parser
2. Context Loss: ASTs contain syntax but not the purpose behind the code
3. Framework Differences: An Angular component is fundamentally different from a Flutter widget
4. Business Logic Extraction: Business rules were hidden in God classes and were difficult to identify
5. Low Success Rate: Even with perfect ASTs, you often only achieve 60-70% automation

The result? Projects that took months, high costs, and often an end result that still needed to be updated manually.

A New Era with AI Agents

When AI code assist tools like GPT-4 and Claude became mainstream, we initially saw an opportunity to improve our traditional AST approach. We started using AI to “understand” code instead of building platform-specific parsers.

But during our experiments, we got a crucial insight: we don't really need AST at all.

Our plans with AST were unrealistic and would never exceed the 60-70% success rate mentioned earlier. The problem lay in the fundamental approach:

The Paradigm Shift

Traditional Approach:

❌ Too literal, misses the point.

Our New Approach:

✅ Understands intent, generates modern code

Instead of “translating” code, we reverse-engineered specifications that an AI agent can then implement freshly.

Abstract Model: The New Approach

Our new system not only extracts code structure, but creates a Universal Application Model that captures the complete essence of each application:

Why This Is Much More Effective

Success Rate: ~ 85-95% for most features because:

• AI agents understand “build a login page” better than “translate this JSX to Flutter”
• Natural language is universal — no complex AST transformations required
• AI has seen millions of examples and knows best practices (with the right guidance)
• Refactoring is implicit
• AI doesn't create God classes (with the right rules!)

Hybrid Approach: Dual Layer Extraction

During our experiments, we realized that we need more data to keep the new applications compatible with existing integrations: semantic understanding AND exact technical contracts. This led to our “Dual Layer Extraction”:

Layer 1: Exact Technical Contracts (1:1 Preservation)

Layer 2: Semantic Context (Intended for AI)

Of course, our “Dual-Layer” approach was very useful, but we wanted to make it even more complete, without “over-engineering” things, of course.

Layer 3: Design System

The third crucial layer we discovered is the design system. Without it, the new app would be functionally correct but look completely different:

Complete Extraction Workflow

Challenges: Simplicity is Key

The biggest challenge in developing this system was not to become too complex. We had a tendency to support every edge case, but realized that:

1. 80/20 Rule: 80% of applications follow standard patterns
2. Perfect Automation is Unrealistic: 85-95% automation is already revolutionary
3. Human-in-the-loop: Complex cases still require human input
4. Incremental Improvement: The system gets better as it sees more codebases

Realistic Expectations

• Simple CRUD features: 90-95% automated
• Complex business logic: 80-85% automated
• UI/UX implementation: 85-90% automated
• System integration: ~ 70-80% automated

Rebuild: From Legacy to Industry Standards

The great thing about our approach is that we don't copy 1:1, but rebuild from the ground up with modern standards:

Transformation from Legacy to Modern

Paradigm Switches Possible

Because we work with semantic specifications instead of literal code translation, we can effortlessly switch between paradigms:

• Object-Oriented to Functional: React class components to hooks
• Monolith to Microservices: Splitting Large Applications Into Services
• Imperative to Declarative: jQuery to React/Vue
• Desktop to Mobile: WPF to Flutter/React Native

Code Coverage Revolution

Legacy systems often have 0-20% test coverage. Our AI agents automatically generate:

1. Unit Tests: For each function and component
2. Integration Tests: For API endpoints and data flows
3. E2E Tests: For complete user journeys
4. Property-Based Tests: For business rule validation

The result? Nearly 100% code coverage from day one.

Conclusion: The Future Is Now

What started as an effort to improve AST parsing evolved into a complete paradigm shift in how we approach legacy code modernization. By focusing on intent rather than implementation, we can:

• Work faster: Weeks instead of months
• Better quality: Modern, tested code from the start
• Lower costs: 85-95% automation
• Reduced risk: Validated functionality and design

At Blis Digital, we will continue to develop and refine this technology. If digital innovation partner we guide organizations in their modernization journey from legacy to future-proof systems. The future of software modernization is not translating old code, but understanding what it does and rebuilding it as it should.

Interested in how this approach can transform your legacy systems? Contact us for an exploratory meeting.

‍