Modernising an interface screen by screen keeps cost linear in the number of screens, even with agents. Defining a grammar of what a screen can be gives a fixed cost and then a falling cost per screen. This is a claim about rate: agents on domain languages reach up to 85% accuracy under four conditions, which does not permit unattended conversion.
The user interface is the second layer to move. It is safe to work on for a structural reason: the interface depends on the layer beneath it, and nothing beneath depends on the interface. So it can be replaced wholesale while the business rules stay fixed, and each result can be compared against the version it replaces. This is the standard modernisation argument. The part that has changed is the achievable rate.
A large platform has hundreds or thousands of screens. The conventional programme treats each one as a unit of work: a UX team produces wireframes, a coding agent implements against them, a reviewer checks the result, and the programme advances one screen at a time. Adding agents to that pipeline makes each unit faster and leaves the shape unchanged. Progress stays linear in the number of screens.
The vertical route asks what would have to be true for the whole surface to be modernised in one pass, rather than how quickly one screen can be done. The answer is that the agent needs a target narrow enough that a malformed screen is rejected before it reaches the product, and a check it can run without a human looking at the output.
The economics change shape. There is a fixed cost to define the grammar and write the compiler, then a marginal cost per screen that falls as the corpus of converted screens grows, because each new screen is written against a language with working examples in it. The first handful need close supervision to confirm the grammar covers what the screens actually do. After that the constraint moves from review capacity to grammar coverage.
In an existing product the compiler emits source code at build time, which is then reviewed and deployed through the normal pipeline. Generating the interface at run time from the document is a different proposition and needs a platform that accepts a desired-state description, which section 13.1 returns to.
This is a claim about a rate rather than about a guarantee, and the supporting evidence is specific. Microsoft's engineering guidance reports coding agents on bespoke domain languages often starting below 20% accuracy, with confabulated APIs, and reaching up to 85% once four things are in place: curated seed examples, explicit domain rules, compiler-in-the-loop validation, and schema exposure (AI Coding Agents and DSLs, Microsoft vendor blog). Twenty percent to eighty-five percent is the measured range, the four conditions are the cost, and 85% does not permit unattended conversion of a revenue-bearing surface.