Legacy migration you can put a number on.

The old system runs the business. Every rewrite estimate came back as a multi-year programme with the roadmap frozen, so the decision slid another year. I run legacy migration as its own engagement with its own measure: did the behaviour survive, and what will the rest cost. Agents do most of the reading and rebuilding. The checks around them decide whether you can trust what they built.

01

What you get, at minimum and at best

At bestOne context moved, and a number for the rest.

We move one more bounded context of your system onto the new architecture, typically with about a third of one of your teams over about three months, sized in scoping. That context is half the result. The other half is an estimate for the rest of the system, built from what this migration actually cost. The estimate is what lets an owner or a board decide on the remainder, so the engagement is judged on it as much as on the code that shipped.

At minimumFar better documentation of the old system.

The floor is written into the engagement. Step one generates a documentation layer for the whole codebase. If the migration stalls for any reason, you keep documentation of the old system that is far better than what you had, and the knowledge that lived in a few heads is written down.

02 / Method

Five steps, in this order

  1. 1Document the codeAgents read the whole codebase, plus whatever documentation exists, and write a documentation layer from it. Where the system has a user interface, agents also drive the running product and record what users see and do. The new system gets written against this layer, so it gets checked by people who know the system before anything else happens.
  2. 2Find the gaps, then interview the people who knowThe generated layer has holes wherever intent never made it into code. Structured interviews with the people who carry that knowledge close them. It is the unglamorous part, it is always on the plan, and it gets its own budget.
  3. 3Rebuild against the documentationNew code is generated from the documentation layer into the target architecture. Every generated unit is compared back to the original code, every time.
  4. 4Check behaviour against the old systemThe strongest check available wins. Best is old and new running live side by side on the same inputs. Then the old system's own tests, then characterisation tests generated from recorded behaviour, then comparing inputs and outputs at API or batch level.
  5. 5A person signs offThe checks show that new behaves like old. Someone who knows the business confirms it does what it should. That gate stays on for the whole engagement.
03 / Cut-over

Two ways to cut over, one rule for both

The ruleThe new system is rebuilt from what the old one is for (the business rules and the intent behind them). Line-by-line translation copies the old structure into the new architecture, and that is where migrations burn months. I have watched teams abandon a strangler-fig migration that tried to carry the old code across piece by piece.
Route A · per feature

Strangler-fig, rebuilt per feature

New features take over from old ones one at a time, while both systems run. Each feature is rebuilt with the old system as its spec: documented, gaps closed by interview, checked against the old behaviour, then switched over.

Fits whenThe system has places to route traffic between old and new, and data can be read from both or moved in stages.
Route B · per context

Clean-room, rebuilt per context

A whole bounded context is documented from the code and from the running product, rebuilt from those specs by agents that never see the old source, and checked by replaying recorded behaviour against old and new. Then the context switches over in one step.

Fits whenThere are no clean places to cut in between, or a full documentation pass is worth having anyway.

Which one fits gets decided in the first weeks, per context, and the data decides more often than the code. An estate whose data cannot be moved in stages cannot be strangled, and that changes the plan and the risk.

04

Why it runs apart from the factory work

A migration and a Code Factory Build look alike, because both put agents on your codebase. They need different setups. The factory is built for a long-lived stream of new work, reviewed and improved run after run. A migration happens once. It needs a documentation layer and a reliable check against the old system, and the full spec-and-review pipeline would only slow it down.

So it gets its own engagement, its own measure and its own fee. Your teams on modern code can start the factory work at the same time.

05

What makes a codebase easy or hard

Old syntax is rarely the problem. Current models read COBOL, Delphi or a house language well, especially when the code sits inside structured containers. Two things predict the effort: how the code is organised, and whether its behaviour can be checked.

Unit tests are the biggest accelerator, even in the old technology. They turn step four from building a check into translating one you already have. Clean domain boundaries come next, because they let the work move one bounded context at a time, which is what makes it estimable.

The real risks sit elsewhere. Knowledge held by one person, especially someone near retirement or working part-time, puts the interviews on the critical path. Data that cannot be exported cleanly rules out moving in stages. I check both before promising a timeline.

06

What the checks cannot tell you

A check against the old system proves the new one behaves the same. It says nothing about whether the old behaviour was right. Every divergence gets a decision: keep the old behaviour, bug and all, or fix it on purpose and write that down.

Recorded behaviour also misses rare paths. Year-end runs, regulatory reports and error handling may never show up in a sampled week of traffic, so they get seeded with historical data and named test cases. Data migration is its own piece of work with its own risk, and it gets planned as one.

07

What the public evidence says

80%of the code changes that landed in one large internal migration were fully AI-authored, and total time dropped by an estimated half. On another, the bottleneck was how fast engineers could review, and they limited weekly changes to protect the reviewers.
Google
6 weeksto move nearly 3,500 test files to a new framework, against an estimate of 1.5 years by hand, with 97% done by the automated pipeline.
Airbnb
Side by sideGuidance for COBOL modernisation runs old and new side by side and has the model write tests that compare their outputs.
Anthropic

Those were code-to-code moves on codebases that already had tests. A twenty-year system without tests is slower, and the first weeks go into building the checks. I say that at the start, because it is what makes the estimate believable.

08

Also for vendors moving a customer base

Some vendors have most customers on old versions of their product. The limit there is professional-services capacity, because every customer's customising has to come across. The same method pulls the intent out of that customising and rebuilds it on the current product.

The target is customising that survives the next release with close to zero effort. That needs stable extension points and APIs in the product, which backends usually have and frontends often lack. Success shows up as migration work that never has to happen, so that is how it gets measured.

09 / Fee

Priced in phases, each one fixed

Phase 0Migration ScopingCHF 15-25kFixed fee, fully credited against Phase 1.
Phase 1One bounded context plus the estimatefrom CHF 60kA fixed quote per bounded context, typically CHF 60-120k.
At riskSuccess component20% of the Phase 1 feePaid when the migrated context passes the behaviour checks and human sign-off and the estimate for the rest is delivered. It never depends on the size of the estimate or on what you decide next.
Prices exclude VAT.

Common questions

What does it cost?

Migration Scoping is fixed at CHF 15-25k and fully credited against Phase 1. Phase 1 is a fixed quote per bounded context, from CHF 60k and typically CHF 60-120k. 20% of the Phase 1 fee is held at risk and paid when the migrated context passes the behaviour checks and human sign-off and the estimate for the rest is delivered. It never depends on the size of the estimate or on what you decide next. Prices exclude VAT. Start with the readiness checklist and a 30-minute discovery call.

Which stacks does this work on?

It is not tied to one source technology. COBOL, Delphi, VB6, an ageing Java or .NET monolith, a house language with its own IDE, a PHP application that grew for fifteen years. Structure and testability decide the effort far more than the language does. The target stack stays your decision.

We have no tests and little documentation. Is that a blocker?

It is the usual starting point. The documentation layer is step one, and the checks get built before anything moves. That takes longer than on a codebase with tests, and the estimate says so openly.

Can agents translate the whole thing in one go?

They can produce the code quickly. The slow and expensive part is proving it behaves like the old system, and translating structure line by line carries the old architecture's problems into the new one. Rebuilding from the documented intent, with checks against the old system, is what holds up.

What happens after the engagement?

You decide with a number in hand. Run the rest yourselves with the setup and documentation you now have, bring me back for it, or stop. The estimate is written so an owner or board can read it.

Is this safe for a critical system?

Parity gets measured. Where the system allows it, old and new run side by side on the same inputs and every divergence gets looked at. Anything that matters goes past a named person before it ships.

Does this replace the Code Factory Build?

They run side by side. Teams on modern code get the factory; the legacy core gets the migration engagement. The documentation and checks the migration leaves behind also lift the old codebase up the readiness levels, so the factory can reach it later.

Engage

Start with one call, then a diagnostic or a scoping.

We go through where your R&D org stands, which codebases are ready, and whether the programme or a single module is the right first step.