Product1 publisher2 min readPublished
Red Hat pitches its migration factory against a Stanford figure of 0-10 percent on legacy code
Red Hat's post puts generative AI's productivity gain on the hardest enterprise codebases at 0-10 percent, then offers a pipeline that grounds the model in migration rules a customer's own team has to write and curate.
The Product Desk · Product desk

What happened
- Red Hat's post cites a Stanford software engineering productivity study putting generative AI gains at 30-40 percent on greenfield work, 15-20 percent on low-complexity legacy systems and 0-10 percent on highly complex enterprise codebases.
- The post blames context fragmentation, where a model sees only a narrow slice of the codebase and guesses at dependencies, along with a rework loop and a verification tax that consume the early time savings.
- Red Hat's answer is what it calls an intelligent AI migration factory, a structured automated pipeline in which an agent makes source-level code changes without a team of developers.
- The two toolkits behind it, MTA for applications and MTV for virtual machines, are included as part of Red Hat OpenShift as an application platform.
- Lightspeed pairs MTA's analysis with the customer's preferred large language model, public or self-hosted, which Red Hat frames as meeting data privacy and sovereignty requirements.
Compiled by The Product DeskSomething wrong?How this is made
Why it matters
- constraint The 0-10 percent band covers exactly the systems enterprises are shopping for help with, so a migration plan costed on greenfield-scale gains has no slack in it.
- decision For a platform team already on OpenShift the call is triage: which migration workstreams route through the rule pipeline, and which need senior reviewers whatever the agent proposes.
- exposure Anyone putting the 0-10 percent figure into a business case is leaning on a vendor's summary of a study named only by university.
- capability Applying one fix across every occurrence in an application moves the review unit from the file to the rule, so a wrong rule propagates as fast as a right one.
A developer running Red Hat Developer Lightspeed for MTA can apply a suggested fix to a single occurrence of a migration issue or to every occurrence in the application, from the IDE [11]. Then they read the diff. Of the three stalls Red Hat lists, the pipeline is aimed at the first: MTA has already scanned the code and pinned each issue to its exact location, and Lightspeed builds its fix from that analysis plus the Kantra ruleset instead of inferring the dependency graph on its own [9][10]. Auditing the generated code, and proving it meets security, performance and compliance standards, still lands on whoever reviews the change [4][5]. Red Hat's stated outcomes for the combination are accuracy and single-click application [19].
Take the cited bands at their midpoints. Greenfield is 35 percent and the highly complex enterprise codebase is 5 percent, so the claimed effect on the hardest work is one seventh of the effect on the easiest [16]. Read as effort saved, a job estimated at 100 developer-weeks unassisted lands at 65 weeks on the greenfield number and 95 weeks on the complex one [17]. Thirty weeks of plan sit between those two figures, and the 0-10 percent band is the one that covers maintaining legacy infrastructure [2].
What teams tell themselves about a migration factory is that the agent does the migration. What this pipeline asks for is rules. Kantra rules are open source and support polyglot languages, and Red Hat says an existing code assistant agent such as Claude or Cursor can create them [10][14]. The example in the post matches one pattern: a Go reference to v1beta1.CustomResourceDefinition, labelled for a Kubernetes target, with an effort field set to 1 [13]. Someone still has to know that pattern matters in your estate, write the rule, and keep improving the context in the integrated solutions server that Red Hat says lets a team of developers steer a large-scale migration [18].
So sort the backlog on two axes before deciding what the pipeline is for. First axis: whether the change can be stated as a pattern match, the way that CustomResourceDefinition rule is [13]. Second axis: how expensive verification is, meaning who reads the diff and against what standard [5]. Rule-shaped changes with cheap verification are where a grounded pipeline should beat a general-purpose assistant, because the model is handed the location rather than hunting for it [9]. Changes that resist a rule, or that a compliance reviewer has to sign, sit in the band the cited study puts at 0-10 percent, and they should be staffed and costed there [2].
What to watch
- Whether Red Hat publishes a measured before-and-after from a customer migration run through Lightspeed for MTA, with a percentage attached.
- Whether the Stanford study behind the 30-40 and 0-10 percent bands is identified so its method and sample can be checked.
- Whether rules curated in the solutions server travel between customers or stay locked to one estate.