A developer and friendly robot review a code-driven mobile app architecture and performance dashboard.
David Ortinau, a Microsoft principal product manager for .NET MAUI, spent a few months testing a question many mobile teams are asking. If an AI coding agent can write a second native UI, does the case for a single cross-platform stack still hold? His answer is "mostly yes, with caveats". The numbers behind it are more useful than the headline.

This is one developer's experiment on one app. It is not a framework benchmark. It is still a rare case where the build cost, the maintenance cost and the runtime results were measured on the same codebase.

A developer and friendly robot review a code-driven mobile app architecture and performance dashboard. The setup: one app, two UI strategies​

The test app is Barista Notes, a coffee journal built with .NET MAUI for Android, iOS, macOS and Windows. The post describes about a dozen screens, more than 20 NuGet dependencies and roughly 31,000 lines of hand-written C#. The UI uses MauiReactor, a fluent C# approach with no XAML. That matters when you read the size and startup numbers.

In September, agents rebuilt the iOS and Android versions as "platform UI" over a shared class library. That means UIKit on iOS and Android Views on Android, both written in C# through .NET for iOS and .NET for Android. It does not mean SwiftUI or Jetpack Compose. The original MAUI app stayed as the reference and still ships the Mac Catalyst and Windows versions.

Only two approaches were measured: MAUI Controls and platform UI over shared code. Blazor Hybrid and drawn UI were discussed but not tested.

Cost to build: three days and under four hours of human time​

The rewrite ran September 25 to 28 in a single GitHub Copilot session. A coordinator agent split the work between platform implementers and independent reviewers, 13 agent identities in all. The recorded totals were:

  • 58 hours of aggregate model time
  • About 3.293 billion gross input tokens, made up of 3.185 billion cache reads, 107.843 million cache writes and 66,276 remaining input tokens
  • 7.8 million output tokens
  • 699 passing tests

Those token categories are parts of the gross total, not extra usage. They also include context re-processed on every call, so they do not measure how much was newly asked for. The models were mostly GPT-6 Astra at High and Extra High effort, with GPT-6 Sol and GPT-5.6 Sol also contributing. Ortinau says the record cannot support a reliable dollar figure. A subscription price wouldn't either. His own prompting and validation time was under four hours, by his estimate.

That figure covers the first pass only. Later parity reviews found behavior gaps and an intermittent Android startup issue. Fixes and device checks after the record ended aren't counted.

What happened to code sharing​

Shared code across the two mobile apps fell from 99.2% to 40.4%. Each app on its own is still more than half shared. The shared Core is 56.4% of the Android app and 58.7% of the iOS app. Core grew from 10,152 to 15,869 lines as logic moved out of pages. Total product code grew 26.1%.

Cost to maintain: the same feature, twice​

Next, each version got the same new feature: a map of bean origins, built with Mapsui and cached place lookups. Each version had its own agent running gpt-6.1-sol at High effort. Shared code was counted once for the platform UI pair.

Measure.NET MAUI.NET for iOS + Android
Model minutes87.6121.2
Model calls254368
Output tokens261,000375,000
Product lines added2,0272,795
Test lines added9461,286
Defect and technical feedback items1319

Platform UI took about 1.4 times the worker model time, and the test additions were 1.36 times larger. A second UI did not double the worker time, which Ortinau credits to writing the shared Core once. It did add real work. One example of the extra feedback: on Android, a list row needed two taps to open the bean detail page, while iOS needed one.

The coordinator was the expensive part​

The coordinating agent planned the work, ran builds, checked the running apps and routed feedback. It used 616 minutes, against 209 for both implementation groups combined. Part of that was the comparison harness itself, which was not charged to either side. Even so, it is the clearest signal in the post that verification can cost more than writing the code.

The table is a snapshot from October 3. That was after both versions ran in the simulator and emulator, and before sign-off. Later fixes aren't counted.

Runtime results: platform UI was faster, with caveats​

On November 18, Ortinau reran the measurements on an iPhone 15 Pro and a Pixel 5, using the same 1,000-drink dataset. He used the .NET 11 SDK (11.0.100), GA runtime packs and MAUI Controls 11.0.0. He also aligned Entity Framework Core and Microsoft.Extensions packages to 11.0.0, while third-party packages stayed at their original versions. The isolated MAUI benchmark copy needed iOS scene-lifecycle wiring for the GA toolchain.

The headline comparison puts both apps on full composite ReadyToRun, so the UI choice is separated from a runtime-setting difference. These are medians.

MeasureMAUI iOS.NET for iOSMAUI Android.NET for Android
Startup (30 launches)569 ms367 ms1,233 ms615 ms
Signed package58.87 MiB49.09 MiB45.64 MiB31.74 MiB
New Drink to history (10 samples)660.5 ms115.0 ms826.8 ms381.0 ms
History to Settings (10 samples)283.3 ms43.9 ms102.7 ms62.1 ms

That works out to a 35% lower startup median on iOS and 50% on Android. The packages were 17% and 30% smaller. The sizes are signed arm64-only APKs on Android and signed IPAs on iOS, with the test fixture and probes included. They are not store download sizes.

Defaults tell a different story​

Android Release defaults differ between the two stacks. MAUI uses partial composite ReadyToRun, and .NET for Android uses full composite. Compared default to default, platform UI started in 615 ms against 1,192 ms. That is about 48% faster. Its APK was 31.74 MiB against 28.84 MiB, about 10% larger. The package win disappears when you compare defaults.

The size gap is also muddied by dependencies. The MAUI app carries MauiReactor, toolkits and popups. The experiment does not isolate the size of MAUI Controls alone.

Navigation results depend on the route​

On Android, platform UI had the lower median in five of six configured comparisons. The exception was the short Settings route under NativeAOT. There MAUI measured about 43 ms against 47 ms, with overlapping sample ranges. On iOS, platform UI won every measured route.

These are screen-navigation measurements that include data loading, view construction and frame scheduling. They are not Activity-launch measurements and they don't isolate framework overhead. Both Android versions stayed inside one Activity. MAUI used Shell, and the platform UI version swapped view trees inside MainActivity.

How much to trust the measurements​

  • Each startup result has 30 launches after one pilot and five conditioning launches. Navigation used ten fresh-process samples.
  • Android startup used am start -W TotalTime with a separate readiness check. It is not time-to-fully-interactive.
  • iOS timing ran from process start until New Drink was ready and two display frames completed.
  • Reverse-order runs reproduced the direction of the results, but some medians moved substantially.
  • Compare apps within a platform, not iOS against Android.

NativeAOT: treat it as experimental​

Microsoft's own documentation agrees with the post's caution. Android NativeAOT is experimental in .NET 11. In the benchmark, the GA builds still carried trimming and AOT warnings, which were accepted only for this isolated test. One MAUI iOS NativeAOT memory run did not reach probe readiness within 65 seconds, and its cause was not isolated. A separate timing confirmation moved that configuration's startup median from 349 ms to 505 ms. A fast route is not proof that the whole app is safe under NativeAOT.

Why the .NET 11 baseline matters​

Ortinau advises measuring against a current MAUI build. In .NET 11 and later, CoreCLR is the default runtime for .NET MAUI apps on Windows, Android, iOS and Mac Catalyst. NativeAOT is an opt-in alternative for publishing on all .NET 11 targets.

Microsoft's breaking-change guidance for the Mono-to-CoreCLR move also applies here. It says to use the R2R defaults from the mobile workload. It adds that you should use MauiEnableFullReadyToRun only after you measure the app, and measure startup time, speed, memory use and app size. That is why the matched full-R2R comparison and the default-to-default one tell different stories.

Anyone comparing against an older Mono-based MAUI build is comparing against a runtime that .NET 11 no longer uses. That would likely make MAUI look worse than it is today. This is an inference, not something the benchmark tested.

The decision matrix, revisited​

FactorWhat the experiment showed
Team knowledgeAgents wrote the UIKit and Android Views code. Someone still had to spot what was wrong on each platform.
Cost to buildA first-pass second UI was practical: about three days and under four hours of human time.
Cost to maintainAbout 1.4 times the worker model time and more feedback items for one feature.
VerificationThe biggest cost: 616 coordinator minutes against 209 for implementation.
Ecosystem and supportNot tested. Both versions still relied on shared libraries such as Mapsui.
RuntimeMatched builds favored platform UI. Android defaults traded startup for package size.

The work AI doesn't remove is the work around the code:

  • Testing user journeys on every platform UI you own
  • Device validation for every UI-heavy change
  • Triage of platform-specific bugs a shared UI wouldn't have
  • Pull requests with larger diffs and reviewers who know each platform

How to run this experiment on your own app​

Ortinau's recommended procedure is practical, and it suits any team:

  1. Pick the screens where platform UI matters most, and start with one. Either embed it, or add a platform app project next to your MAUI app.
  2. Measure one real user journey against a current .NET 11 MAUI build.
  3. Change a requirement and implement it in both versions. The first port shows construction cost. The second change shows maintenance cost.
  4. Budget for tests, device checks, triage and review, for both people and agents.

He lists several situations where platform UI makes sense:

  • Platform look and feel is the product.
  • You've measured a startup, size or screen-performance problem that platform UI fixes.
  • You want direct control of navigation, lifecycle and platform integration.
  • You can staff verification on each platform.

You can also mix approaches by screen or by platform. Barista Notes does this today. It uses platform UI on iOS and Android and MAUI on Mac Catalyst and Windows, with one shared Core underneath. MAUI views can be embedded in a platform app with ToPlatformEmbedded.

Tooling the agents used​

Ortinau ran both phases as GitHub Copilot app sessions, with subagents per platform and separate reviewers. Agents also need to see the running app. He used three tools for that:

  • DevFlow, which reads the visual tree, taps, types, takes screenshots and inspects logs and network traffic. It ships in .NET MAUI Labs, which is experimental and outside the MAUI support policy.
  • Ailoha, which does similar work across frameworks and is included in Debug builds of the iOS and Android apps.
  • Mobile Canvas, which streams the iOS Simulator and Android emulator into the Copilot app.

Ailoha and Mobile Canvas are early, experimental projects from Jonathan Dick.

Analysis: what to take away, and what to discount​

The source is a Microsoft product manager writing on Microsoft's own blog about a Microsoft framework. Ortinau discloses many limits himself, including the dependency differences, the uncounted fix-up work and the mixed evidence on defaults. Even so, the sample is one app, two devices, one developer and one agent setup.

Three points stand out:

  • The cost shifted. Writing a second UI no longer looks like the hard part. Owning it does, through review, device testing and triage.
  • Performance gains are real but conditional. They depend on the build settings and the route. A mid-size app with a different dependency graph could land elsewhere.
  • Recommendations barely moved. He still starts with a single shared UI because it means less UI code to own. What changed is that trying platform UI for one screen is now cheap enough to measure before committing.

The post doesn't test ecosystem health, which is one of the factors in the matrix. It also doesn't say how an agent-built UI holds up over years of OS updates. Those questions remain open.

For teams that reevaluate their stack every year, the useful move is to run a small, measured pilot instead of arguing from assumptions. Port one screen and change one requirement. Compare the results against a current MAUI build on your own devices.

 

References

  1. AI is Changing the Cross-Platform Decision Matrix .NET Blog 2026-11-20T18:00:00+00:00
  2. Breaking change - Code generation on mobile changes from Mono to CoreCLR - .NET learn.microsoft.com
  3. Runtimes and compilation in .NET MAUI - .NET MAUI learn.microsoft.com