Most software modernization projects do not fail because of technology. They fail because nobody knows anymore what the old system actually does.
The code is there. It runs. It carries the business every day. But the people who wrote it are gone, the documentation is outdated, and the requirements only exist implicitly in the code. When you start a rewrite in this situation, you are guessing. And guessing at enterprise scale is expensive.
This is the problem the Brownfield Workflow of the AI Unified Process (AIUP) solves.
Start from the running system
In a greenfield project, AIUP starts with requirements. A Requirements Engineer writes use cases and an entity model, and the AI agent generates code and tests from these artifacts.
In a brownfield project, we turn this around. We start from the running system and recover the requirements from the code.
The AI analyzes the existing codebase, the configuration, and the database schema. From this analysis, it produces the same artifacts a greenfield project would have:
The entity model describes the business data and its relationships. The use case model shows what the system does and for whom. The use case specifications describe each function in detail, including the flows and business rules hidden in the code.
This is not magic, and it is not fully automatic. The Software Engineer and the Requirements Engineer review every artifact. AI-generated specifications contain errors and gaps, especially where the code itself is unclear. The review is where recovered text becomes validated knowledge. But instead of spending months on manual archeology, the team spends days on reviewing and correcting.
The specs become the foundation
Once the specifications exist, the legacy system joins the normal AIUP workflow. From now on, every change starts with a requirement, not with code.
Is the current behavior wrong? Then it is a bug, and we fix the spec and regenerate. Do we want new behavior? Then it is an enhancement, and we extend the use case first.
Tests protect the system during this transition. They capture the current behavior, so the AI can regenerate code without breaking what the business depends on. This is what makes iterative modernization possible. You do not need a big bang. You modernize use case by use case, while the old system keeps running.
A real example
We used this approach in an ERP modernization at a Swiss wholesaler. Instead of rewriting the monolith, we carved out a new Self-Contained System and built it with AIUP: recovered specifications, a clear entity model, generated code with Vaadin and jOOQ, and a comprehensive test suite.
The result surprised even me. After a few months, the team had a new kind of problem. Feasibility was no longer the question. Every user request could be implemented, usually within days. The discussion shifted from “Can we build this?” to “Should we build this? Does it really improve the work of the user?”
That is what modernization should achieve. Not just newer technology, but a system the team fully understands and can change with confidence.
Why this works
The key insight is simple. The value of a legacy system is not the code. It is the business knowledge encoded in it. Classic rewrites throw this knowledge away and try to rediscover it, which is why they take years and still miss requirements.
The AIUP Brownfield Workflow extracts the knowledge first, validates it with humans, and then uses it to drive the modernization. The specifications outlive the old code, the new code, and even the team.
If you want to learn more about the methodology, visit unifiedprocess.ai. And if you have a legacy system that has become a bottleneck, have a look at my Software Modernization offering.
