Large-scale porting is considered the most unpleasant category of project in software development: a lot of effort, little visible benefit, high risk.That is precisely why long-established codebases often stay on a technology for years that nobody would voluntarily choose any more.A report on a migration project at GitHub shows that this calculation is currently shifting: around 800,000 lines of code were converted there from TypeScript and Node.js to Rust – with AI support that made the undertaking economically viable in the first place.Human oversight remained indispensable.

Why porting usually gets left undone

In the ideal case, a language migration produces not a single new feature.The product behaves exactly as before afterwards, just on a different technical foundation.The benefit lies in properties that are hard to translate into roadmap items: runtime behaviour, memory requirements, maintainability, availability of developers for the respective language.

This is offset by an effort that grows linearly with the amount of code.With six-figure line counts, manual translation is generally no longer a realistic proposition, because it ties up teams for months while they must also serve ongoing business.The result is familiar from many companies: the migration has been on the list for years and is postponed every year.

What changes through AI support

Language models are comparatively strong at exactly this kind of work.A port is to a large extent a translation task with a clear template: the target structure is known, the desired semantics are in the source code, and there are typically tests against which the result can be checked.Unlike new development, the model does not have to guess what is meant – it has to transfer what already exists.

This shifts the cost side significantly.If a considerable part of the mechanical translation work runs automatically, staffing shifts from generation to review.A project that would previously have failed on sheer volume becomes plannable as a result.

The review layer remains

The central point of the GitHub report, however, is not automation but its limit: without human oversight, the result was not viable.This matches what can generally be observed in AI-assisted code work.

Generated code looks plausible.It often compiles, it reads cleanly, and it matches the style of the target language.Whether it does the same thing as the original in all edge cases is not thereby established.Particularly delicate are places where the languages differ conceptually – for example in handling concurrency, error handling or the lifecycle of objects.That is exactly where deviations arise that no test suite automatically uncovers if the tests themselves come from the old world.

In practice this means: the time saved does not land entirely on the credit side.Part of it goes into review, into additional tests and into the targeted follow-up of places where the automation reaches its limits.

Transferable to mid-sized codebases

Few companies face a port of this magnitude.But the structure of the problem is the same when an older PHP application is to be raised to a current version, a TYPO3 instance is to be migrated across several major versions, or a self-built extension is to be converted to a current API model.

For such undertakings, several points can be derived from the approach:

  • Test coverage first. Automated translation is only as reliable as the verification behind it.Where no tests exist, they should be created before the migration – against the old system, while it is still running.
  • Work in slices. Modules with clear boundaries can be converted individually and accepted individually.This keeps the review load per step manageable.
  • Plan review as a separate work package. Review is not an appendage but the part of the project that determines quality.It belongs in the planning with its own time and its own responsibilities.
  • Identify critical areas. Payment processing, permission assignment, data exports: where errors become expensive, manual in-depth review is needed instead of spot checks.

What this means for project planning

The interesting consequence is less technical than economic in nature.Migrations that have hitherto been postponed with the argument "too expensive, too long" deserve reassessment.A calculation from 2022 no longer reliably reflects today's effort for such undertakings.

At the same time, nothing changes about responsibility for the result.A team that takes over a codebase must understand it – regardless of who or what wrote the first draft.Whoever buys AI-assisted migration buys faster generation, not a shortcut in quality assurance.

For web and software projects, this shifts above all the question that stands at the beginning: no longer whether modernisation is affordable at all, but how much review effort a particular system area justifies.

Anyone running an established platform and putting off a relaunch should recalculate the feasibility – and at the same time commit budget for testing and review before the development time saved is earmarked for something else.

Sources