Using AI to deliver a codebase migration faster and more cost-effectively.

Maintaining two native codebases feels manageable, until you want to move faster. That's when the bill arrives. The solution? A codebase migration. But until a few years ago, that wasn't a realistic option for most organisations. Too expensive, too time-consuming, too risky. That has changed. AI now makes it possible to modernise existing software faster and more affordably, with more control over the process. And clients feel that directly.

Double the work

Many apps run on two native codebases: iOS and Android. That means four developers, two platforms, every feature built, tested and reviewed twice. When Stichting Lumens, a client of Harborn, wanted to keep developing their platform and ship new features, the structural cost of that setup became impossible to ignore.

Switching to Flutter changed that. One codebase, one team, one development track. Development costs could be nearly halved. The direction was clear. But the real challenge came next: how do you migrate without months of downtime and without losing functionality?

Step by step

Rather than rebuilding everything from scratch, Harborn chose to break the migration into smaller steps. First, a solid Flutter foundation was set up, a structure that keeps the code organised and easy to extend. That takes more time upfront, but prevents a lot of problems later. The existing iOS and Android projects were then added to the same environment, so the original code remained continuously available as a reference.

From that point, every feature was migrated and tested one at a time before moving on to the next. That kept the process clear and manageable throughout.

AI as an accelerator

AI played an important role. Harborn used GitHub Copilot to generate a first version of each feature, not based on a standalone prompt, but with the full codebase as context. That meant existing logic was preserved and edge cases were automatically carried over, rather than quietly lost in a manual rebuild.

Around 90% of the generated code was directly usable or good enough with minor adjustments. Repetitive work in particular moved fast: setting up architecture, scaffolding standard components, and establishing patterns. For more complex parts, animations, custom UI elements, manual work was still needed. AI solutions were often technically correct, but not always the smartest approach. That's where developer experience remains essential.

This is precisely where the value lies for organisations looking to modernise without embarking on another lengthy migration. AI doesn't replace developers, but it dramatically accelerates repetitive work and makes renewing existing software far more efficient.

The results

The full migration took between 100 and 125 hours. Without this AI approach, the same work would have taken at least five times as long. That difference isn't just about speed, it's also about completeness. Manual rebuilds tend to miss edge cases. Because we worked from the existing codebase throughout, those cases were preserved.

To make sure nothing slipped through, the process was tightly structured. A complete list of all features was drawn up upfront. During the migration, the old and new app ran side by side, making any differences immediately visible. Only once the same actions, scenarios and edge cases produced matching results was a feature considered done.

For Stichting Lumens, the impact is clear: faster delivery of new features, structurally lower development costs, and less dependence on parallel development tracks. That creates room to keep building without technology constantly setting the pace.

What this means in practice

By applying AI thoughtfully and breaking migrations into manageable steps, it's possible to modernise existing software without sacrificing quality or continuity. What wasn't feasible for most organisations a few years ago, now is.

At Harborn, this is the approach we use to make migrations practically executable, not just technically, but in the day-to-day reality of teams that need to keep delivering while the work is happening.