Reading a legacy codebase faster with AI
The longest phase of a modernization project is understanding what the current system actually does. This is where AI assistance has changed our numbers the most.
On a typical modernization engagement, the first three weeks are archaeology: reading code nobody documented, written by people who left, in a style that was normal in 2011. It is unglamorous and unavoidable, and it is where the schedule usually slips.
It is also the place where AI assistance has made the biggest measurable difference to how we work.
What it is good at
- Summarising what a large unfamiliar module does, so you know where to look properly
- Tracing a value backwards through layers of indirection
- Explaining a framework or language idiom that predates everyone on the team
- Finding every call site of a pattern, including the ones grep misses because they are spelled differently
- Drafting the first version of the documentation that never existed
None of that replaces reading the code. It replaces the part where you read the wrong forty files first.
What it is not good at
It will confidently describe intent it cannot know. Why a check exists, which of two similar paths is the live one, what the workaround in the middle of a function was protecting against - it will produce a plausible answer, and plausible is dangerous when you are about to migrate something.
So the rule is simple: anything load-bearing gets verified against the running system before it goes in the plan.
The number that matters
Discovery that used to take three weeks now takes closer to one. On a fixed-scope discovery engagement, that is a direct saving to the client. On a build, it means the plan arrives while the problem is still fresh rather than a month later.
That is the honest shape of the benefit. Not "AI writes the migration" - it does not. It gets us to an accurate picture of the current system faster, and an accurate picture is what the whole rest of the project is built on.