Inspiration
Some of the world's most important industries, including aviation, banking, healthcare, and government, still depend on software written decades ago. These legacy systems are often difficult to maintain, expensive to modernize, and risky to replace.
We were inspired by conversations with industry professionals who explained that one of the biggest challenges in legacy modernization isn't writing new code. It's proving that the replacement behaves correctly.
That led us to one question:
What if AI could not only modernize legacy software, but also help verify that the modernized version actually works?
Modernizing code is easy. Proving it works is the hard part.
What it does
AI Legacy Code Engine is an AI-powered modernization and verification platform designed to make updating outdated software more reliable.
Our engine follows a structured workflow:
- Analyze: Examine legacy source code and identify its functionality.
- Modernize: Use AI to generate an updated implementation.
- Test: Generate and execute automated tests against the original and modernized versions.
- Detect: Identify behavioral differences, failed tests, and potential regressions.
- Repair: Use AI to attempt targeted fixes when discrepancies are discovered.
- Verify: Produce a report showing test results and evidence of behavioral consistency.
Rather than simply trusting AI-generated code, our platform introduces an additional layer of automated verification.
The goal is to help developers modernize software with greater confidence while making failures easier to identify and investigate.
How we built it
We developed AI Legacy Code Engine during the 2026 BYU-Idaho iHack hackathon using a combination of modern development tools, AI-assisted programming, and automated testing.
Our technology stack includes:
- Python and FastAPI: Backend services and API orchestration.
- AI-assisted development: Code analysis, modernization, and repair workflows.
- Automated testing: Execution and comparison of legacy and modernized implementations.
- Web-based frontend: An interface for submitting code, monitoring execution, and reviewing verification results.
- Git and GitHub: Version control and collaboration between team members.
- VS Code, Codex, and Antigravity: AI-assisted development and implementation.
We organized the project around a modular architecture, separating the modernization process, verification logic, backend services, and user interface.
This allows us to improve individual components without rebuilding the entire system.
Challenges we ran into
Our biggest challenge was building a reliable modernization and verification workflow within a limited hackathon timeframe.
Generating new code with AI is relatively straightforward. Determining whether that code preserves the original program's behavior is significantly more difficult.
We had to consider several challenges:
- Behavioral equivalence: Two implementations can look completely different while producing the same results, or look nearly identical while behaving differently.
- Test coverage: Automatically generated tests may miss edge cases and unexpected inputs.
- AI reliability: AI-generated code can introduce subtle errors, making independent verification essential.
- Integration: Connecting AI workflows, automated execution, backend services, and a responsive frontend.
- Time constraints: Prioritizing a working end-to-end prototype during a 24-hour hackathon.
- Collaboration: Coordinating development across separate Git branches and multiple AI coding environments.
These challenges reinforced the importance of testing AI-generated code rather than assuming it is correct.
Accomplishments that we're proud of
We're especially proud of turning an ambitious idea into a working prototype within a single hackathon.
Instead of building another AI code-generation interface, we focused on a problem that extends beyond code generation: How can developers evaluate whether AI-generated replacements actually preserve required behavior?
Our accomplishments include:
- Building an integrated modernization and verification workflow.
- Creating a user interface that makes the verification process visible and understandable.
- Implementing automated testing and behavioral comparison capabilities.
- Developing a foundation for identifying and investigating modernization failures.
- Designing a modular system that can support future improvements and additional programming languages.
- Collaborating effectively while learning and integrating new technologies under a strict deadline.
Most importantly, we built a project that addresses a real challenge faced by organizations maintaining legacy software.
What we learned
Our biggest takeaway was that AI-generated code is not automatically reliable code.
Modernization requires more than translating syntax or replacing outdated programming patterns. It requires understanding what the original software does, preserving its intended behavior, and producing evidence that the replacement meets its requirements.
We also learned the importance of modular architecture, automated testing, Git collaboration, and building software incrementally.
Working under hackathon conditions pushed us to make practical engineering decisions, troubleshoot unfamiliar problems, and prioritize the features that mattered most.
Ultimately, we learned that the real opportunity for AI in software modernization isn't just generating code faster. It's helping developers evaluate and improve the reliability of what gets generated.
What's next for AI Legacy Code Engine
This hackathon is just the beginning.
Our long-term vision is to develop AI Legacy Code Engine into a comprehensive modernization and verification platform for organizations working with complex legacy systems.
Our next priorities include:
- Expand language support: Modernize and verify applications written in languages such as COBOL, Java, C, and other commonly used legacy technologies.
- Improve verification: Introduce property-based testing, fuzz testing, static analysis, and formal verification techniques.
- Strengthen AI repair: Improve the engine's ability to diagnose failures and generate targeted corrections.
- Increase test coverage: Automatically identify edge cases and generate more comprehensive test suites.
- Support larger applications: Move beyond individual functions toward interconnected modules and complete systems.
- Explore safety-critical applications: Investigate how the platform could support modernization efforts in aviation, banking, healthcare, and government, where additional assurance and regulatory requirements are essential.
- Improve reporting: Produce detailed, traceable verification evidence that engineering teams can review and audit.
Our ultimate goal is not to replace human engineers or claim that AI can guarantee software correctness.
It's to give developers better tools, stronger testing, and clearer evidence when modernizing the systems that the world depends on.
Modernizing is easy. Proving it works is the hard part. We're building the engine to help solve that.
Built With
- ai
- antigravity
- css
- docker
- fastapi
- github
- grok
- html
- javascript
- llm
- muse
- openai
- python
- react
- testing
- typescript
- vscode