Databricks

AI Makes Migrations Faster. It Doesn't Make Them Easy.

Summary

AI makes migrations faster, but not easier. AI changes how fast we write the code. It doesn't change what makes a migration succeed or fail: knowing whether it is a lift and shift or a lift and modernize, capturing business meaning, writing the mapping before the code, and validating automatically.

Last Updated

19 Nov 2026

Published

19 Nov 2026
An old stone arch bridge and a new modern bridge running side by side across a still river at sunset, a metaphor for migrating from a legacy system to a new platform.

“AI changes how fast we write the code. It doesn't change what makes a migration succeed or fail.”

TL;DR

  • AI changes how fast we write the code. It doesn't change what makes a migration succeed or fail.
  • First decide whether it is a lift and shift or a lift and modernize. “We rewrote it with AI in six weeks” usually describes a lift and shift.
  • What slows migrations down is business meaning, not technology. AI can tell you what the code does, not why.
  • Write the mapping before the code. Business owners can sign off on a mapping. They can't sign off on 40,000 lines of generated code.
  • Validate automatically: row counts, totals and record-by-record differences.
  • Skip this, and AI will just help you get to the wrong result sooner.

Lately it feels like every podcast I listen to has the same guest. Someone who took a huge legacy codebase and rewrote it in a new language with AI, in weeks instead of years. And I believe them. The tools have become remarkably good at translating code.

At the same time, "accelerators" have become the word of the year in our industry. Every vendor has one, and AI is the biggest accelerator of them all. In my own migration work, it really does let us deliver faster.

But after years of moving systems and data from one platform to another, I want to add some caveats to the hype. AI changes how fast we write the code. It doesn't change what makes a migration succeed or fail.

Migrations are still hard

A migration is rarely a coding problem. It's a problem of moving years of decisions, workarounds and assumptions from one place to another, without breaking the business that depends on them.

The old system works, more or less, and people trust its numbers. The new one has to earn that trust. Translating syntax is the easy part. Proving that the new system behaves the way the business expects is the hard part, and it still is.

Start with the question: is it 1 to 1?

Before anyone talks about speed, the first question should be what kind of migration this is.

  • Lift and shift. Move the logic as it is to the new platform. Same inputs, same rules, same outputs. Success is easy to define: the new system produces the same results as the old one.
  • Lift and modernize. Move and improve at the same time. Fix old workarounds, change the data model, retire reports nobody uses. Much more valuable, but much harder to verify.

The trap is that "we rewrote it with AI in six weeks" usually describes a lift and shift. If your project is a lift and modernize, you are not comparing apples to apples. Once you change the logic, you can no longer just check that the numbers match. You have to explain every difference and get the business to agree it is the right one.

Lift and shift vs lift and modernize
Lift and shiftLift and modernize
What movesThe logic as it isThe logic, improved on the way
Success meansThe new system produces the same results as the old oneEvery difference is explained, and the business agrees it is the right one
How you validateThe numbers matchThe numbers match where expected; differences are signed off
Where AI helpsTranslating the codeTranslating the code, not the decisions
Value and effortLower value, easy to verifyMuch more valuable, much harder to verify

The technology was never the real problem

In every migration I've worked on, the technical side was solvable. What slowed us down was business meaning.

Every system carries rules that were added for a reason at some point. Over the years, the reasons get lost, definitions drift, and the same term can mean different things in different places. Often the full picture lives only in the heads of a few people, or with people who have already left the company.

AI can read the code and tell you what it does. It can't tell you why it does it, or whether it should still do it. That knowledge comes from the people who run the business, and getting it out of them takes time no tool can compress.

“AI can read the code and tell you what it does. It can't tell you why it does it, or whether it should still do it.”

Mapping and design documents come first

This is the part of the process that AI doesn't change. Before writing code, we write down how things map: source to target, field to field, rule to rule, and which of those rules are kept, changed or dropped.

It used to feel like overhead to some teams. Now it's the best investment you can make, because those documents are exactly the context AI needs. Give a model the old code alone and it will faithfully copy every old mistake. Give it the code plus a reviewed mapping document and it will build what the business actually agreed on.

Example source-to-target mapping document with a kept, changed or dropped decision for each rule.
An illustrative source-to-target mapping document: every field, every rule, and a decision on each.

The same documents also keep people aligned. Business owners can sign off on a mapping. They can't sign off on 40,000 lines of generated code.

“Business owners can sign off on a mapping. They can't sign off on 40,000 lines of generated code.”

Accelerate the boring parts with frameworks

AI is one accelerator. Reusable frameworks are another, and they matter just as much. Two of them pay off on almost every project:

  • Ingestion. A standard way to bring data from the source into the new platform, so each new table is configuration, not a new piece of code.
  • Validation. Automated comparison of old and new outputs: row counts, totals, and record-by-record differences. This is what turns "the code looks right" into "the numbers match, and here's the proof."

On Databricks, some of this comes ready-made. Lakeflow Connect gives you managed ingestion from common sources, and Lakebridge covers assessment, code conversion (including an LLM-powered converter) and reconciliation between the old and new data. They save real time. But they still build from what you give them: the mapping decides what they produce, and the validation decides whether you trust it.

Validation becomes even more important when AI writes the code. Generated code can look perfect and still be subtly wrong. The faster you produce it, the more you need a fast and repeatable way to check it.

Documentation should feed the code, and prove it

I like to think of documentation as the source, and code as its result. The design says what should happen, the code does it, and the validation shows that it did.

That chain pays off long after go-live. Six months later, when someone asks why a number changed, you can go back and see what was decided and why. It's also the only version of the system that non-technical people can read. A finance manager won't open a repository, but they will open a mapping document.

With AI writing more of the code, this matters more, not less. If nobody wrote the code by hand, the documentation is the only record of the intent behind it.

Faster, not easier

So yes, AI is a real accelerator, and I'm excited about it. It removes a lot of the slow, manual translation work that used to fill migration plans.

But the fundamentals haven't moved. Know whether you're doing a lift and shift or a lift and modernize. Capture the business meaning early. Write the mapping before the code. Validate everything automatically. Keep the documentation as the proof. Do that, and AI will make you faster. Skip it, and AI will just help you get to the wrong result sooner.

“Do that, and AI will make you faster. Skip it, and AI will just help you get to the wrong result sooner.”

If you're planning a migration and want to move fast without losing the business knowledge along the way, we can help at Cosmos Thrace. We combine AI-assisted development with proven ingestion and validation frameworks, and a delivery process built around clear mapping and documentation. Let's talk.

Can AI do a data migration for you?
What is the difference between lift and shift and lift and modernize?
What is a source-to-target mapping document?
How do you validate a data migration?
Does AI-generated code need more validation?
What are the biggest data migration challenges?