Using AI to modernize or migrate code

Let’s be honest, agentic engineering is the most disruptive evolution I’ve experienced in the field of software development (to be fair, I wasn’t there when we moved from cards to assembler).

AI agents are now able to do many things fast at good (to very good) quality. They are particularly good when it comes to code transformation: be it a code modernization or code migration.

Code transformation, the old way

KDAB engineers have completed many migrations over the last three decades: from Qt3 to Qt4 to Qt5 to Qt6, from MFC to Qt, from Motif to Qt… the workflow is always the same:

1. Find a piece of code you want to transform (a class, a dialog, a function),
2. Transform the code to fit your target (be it modernization or migration),
3. Test,
4. Peer-review.

At this point, the transformation is done. In order to apply the same transformation for the rest of the code, we try to automate it as much as we can. This means finding the recipe for the transformation and writing a script to complete it for yourself. I’m using script in a broad sense, it could be a simple Perl script, or a complete software aimed at transforming code (like KDAB’s migration tool Knut).

At this point, you can run the script on other parts of the code to migrate the rest of the software. Still, you need to follow these steps:

1. Apply the script to the code,
2. Finish the transformation if needed (sometimes, the script can only do 80%, as the last 20% are too difficult to automate),
3. Review,
4. Test,
5. Peer-review.

Never apply a transformation globally on the whole code, as it will make the last 3 steps almost impossible! Also, it’s important to note that there is always an infinity of variations of the code, meaning the script will most likely hit a corner case at some point or another, requiring manual help.

Any migration like this is time-consuming. Even if automation reduces the time to market, there are many manual steps required to ensure there are no regressions and the software is still working as expected.

Code transformation, the AI way

AI agents have completely changed the way developers are now working, especially as they are very good with code transformation. And we have seen many small or large codebases being migrated with the help of agents (for example bun, ladybird, google or even anthropic itself).

This leads us to think that with an infinite amount of tokens, one can basically migrate anything. There are now many services proposing AI code transformation with the premise that you just need to swipe your credit card (I will only link MALUS, humoristic one). Such one-click migration services are selling you a fantasy, a disaster waiting to happen.

As much as I find interesting reading those successful migrations, I’m more and more dubious that such migration could be done with a click on a button, based on our collective migration experience in KDAB.

Looking at the different steps done manually, you still need at least to review and test the software yourself. And even having 100% code coverage does not prevent from the agent making mistakes (read the excellent article on rewriting git to rust here).

Every migration project is unique, and it’s important to read the report of those AI-assisted migrations in detail, and why it worked. To my knowledge, none ended up with just one click on a button ;)

Code transformation, the KDAB way

The KDAB team has used AI agents on different projects requiring code transformation, which accelerates the development greatly.

And while all those projects were executed by different persons, the conclusions are always roughly the same.

Do not do any global transformation, but keep the changes small and local as much as possible. This allows the code to be reviewed by a human (as well as AI - nowadays almost a given), to do test focused on what’s changed and to correct and enhance the migration skills.

Write agent’s skills. As every migration is unique, you can easily create your own skills to share in the team and reuse during the migration. This replaces writing a “script” for automating transformation.

Test, test, test. Nothing will replace human testing, to ensure that all features are working as expected. You don’t want to release a new version of your software that has not been field tested beforehand.

In the end, all changes are still going through the CI, reviewed and tested by a human. AI definitely changed our approach to code transformation and improved our velocity. Still, the quality of the work we are delivering needs to be ensured.

Transformation Strategy

One helpful approach is to split the work into three phases:

1. Stabilization phase: before touching the actual migration, use AI to harden the existing codebase. Expand test coverage, prune dead code, and normalize formatting. This is not just cosmetic changes, it will reduce work, conflicts and regressions later on.
2. Pilot phase: the code transformation is done on a subset of the code. This allows to establish the architectural patterns, tooling and the general workflow for the migration.
3. Completion phase: once the foundation is established, the migration continues. The proven approach from phase 1 is applied to the rest of the code instead of trial-and-error.

This approach is preferred by KDAB, as we can set solid foundations during phase one based on our expertise and experience, and gradually let the customer take over the work during the completion phase.

Over 25 years of migrations, we’ve learned that codebases are more than just code: it’s a succession of (sometimes bad) decisions based on context, context that AI agents often lack, that could have ended up with convoluted code or architecture issues. KDAB’s job during the pilot phase is to identify those before blindly copying them in the new code. This allows detecting architectural drift and broken assumptions.

The people factor

We must address another important factor during a code transformation: ownership. AI agents can transform code at the speed of light, but they cannot mentor a team or build a consensus. A migration is only a success if the people who are going to inherit it understand it, trust it and maintain it.

This is why the completion phase is also so important, as it is not just a handover of the code, but a transition period of knowledge transfer, a time for KDAB’s engineers to explain the migration process, the decisions made and the new architecture if needed.

AI accelerates modernization, expertise makes it last

As of fall 2026, you should treat an AI as a highly productive, hyper-capable junior developer with a very short attention span. It is engineered for speed, but it requires consistent, expert supervision.

When it comes to code transformation, there is no "magic button." A successful project requires more than just raw power; it requires a clear roadmap and experience to avoid ‘been there, done that’ traps, as well as a buy-in from the team maintaining the code.

Starting with a rigorous pilot phase helps you validate your assumptions, test the agent’s performance against your specific architectural constraints, and determine whether the migration is truly worth the effort.

Ultimately, while AI agents have fundamentally shifted our approach to modernization, drastically increasing our velocity, they have not replaced the need for deep technical expertise. The value we deliver with the KDAB approach lies in ensuring that the final output is not just "transformed," but stable, maintainable, and built on a foundation that will last for the next decade.