Microsoft testa IA para reescrever app .NET MAUI em UI nativa e mede o custo real
Um experimento da Microsoft reescreveu as telas de Android e iOS de um app .NET MAUI em UIKit e Android Views usando agentes de IA. Os números mostram onde o custo caiu e onde ele só mudou de lugar.
David Ortinau, product manager principal de .NET MAUI na Microsoft, publicou no .NET Blog um experimento que todo time em dúvida entre .NET MAUI e UI nativa deveria ler antes de decidir a stack do próximo projeto. Ele pegou um app .NET MAUI real, pediu para agentes de IA reescreverem as telas de Android e iOS em UIKit e Android Views, e cronometrou cada etapa: construir, manter e rodar. O experimento foi feito entre 25 e 28 de setembro de 2026, com uma rodada de medição refeita em 18 de novembro, já no .NET 11 GA, com SDK 11.0.100 e .NET MAUI Controls 11.0.0.
O ponto de partida importa: isso não é uma migração para fora do .NET. Todo app .NET MAUI já roda sobre .NET for iOS e .NET for Android, e do mesmo C# dá para chamar UIKit ou Android.Views.View diretamente, tela por tela ou no app inteiro. Quando um handler do .NET MAUI desenha um botão, ele cria um UIButton por baixo no iOS e uma View do Android por baixo no Android. O experimento só trocou a camada de controles (Microsoft.Maui.Controls) pela camada de plataforma, mantendo o restante da stack.
O app e o que foi reescrito
O app do experimento, Barista Notes, tem uma dúzia de telas, mais de 20 dependências NuGet e cerca de 31 mil linhas de C# escritas à mão, com UI em estilo fluente e reativo via MauiReactor (C# puro, sem XAML). Ortinau pediu que agentes reescrevessem as versões Android e iOS sobre .NET for iOS e .NET for Android, com UIKit e Android Views, compartilhando uma biblioteca de classes (Core). As versões Mac Catalyst e Windows continuaram em .NET MAUI, sem mudança.
A comparação equivalente já existia antes da IA: em 2017, o engenheiro Jacob Jedryszek relatou cerca de 60-70% de compartilhamento de código construindo o app Azure com Xamarin Native direto em C#. O que muda agora não é a arquitetura, é quem escreve o código de UI repetido duas vezes, e Ortinau queria um número para isso.
Quanto custou a reescrita completa
A reescrita rodou em uma única sessão do GitHub Copilot app, com um agente coordenador dividindo o trabalho entre implementadores de plataforma e revisores independentes, 13 identidades de agente no total. O registro da sessão aponta:
- 58 horas de tempo agregado de modelo
- cerca de 3,293 bilhões de tokens de entrada bruta, incluindo 3,185 bilhões de leituras de cache e 107,843 milhões de escritas de cache
- 7,8 milhões de tokens de saída
- 699 testes passando
- menos de 4 horas do tempo do próprio Ortinau, gastas em prompts e validação
Os modelos usados foram principalmente GPT-6 Astra em esforço alto e extra alto, com contribuição de GPT-6 Sol e GPT-5.6 Sol. O relatório de uso identifica os modelos, mas não estabelece um custo em dólar confiável para a rodada, nem uma assinatura faria isso sozinha.
O compartilhamento de código caiu de 99,2% para 40,4% entre as duas plataformas, porque cada uma passou a ter sua própria implementação de UI. Olhando cada app isoladamente, porém, o Core compartilhado ainda responde por 56,4% do app Android e 58,7% do app iOS: o projeto Core cresceu de 10.152 para 15.869 linhas, porque comportamento que antes vivia nas páginas migrou para código usado pelos dois apps. No total, o código de produto cresceu 26,1%.
Manter custa mais do que construir
Depois da reescrita, Ortinau adicionou a mesma funcionalidade nova, um mapa de origem dos grãos de café com Mapsui e cache de busca de lugares, nas duas versões, cada uma com seu próprio agente em esforço alto.
| Medida | .NET MAUI | .NET for iOS + .NET for Android |
|---|---|---|
| Minutos de modelo | 87,6 | 121,2 |
| Chamadas de modelo | 254 | 368 |
| Tokens de entrada bruta | 10.041.328 | 17.283.666 |
| Linhas de produto adicionadas | 2.027 | 2.795 |
| Linhas de teste adicionadas | 946 | 1.286 |
| Itens de defeito/feedback | 13 | 19 |
A versão de UI nativa usou cerca de 1,4 vez o tempo de modelo da versão .NET MAUI e recebeu mais itens de feedback, alguns deles bem específicos de plataforma:
No Android eu preciso tocar duas vezes numa linha da lista antes de navegar para a tela de detalhe do grão. No iOS, um toque já funciona corretamente.
On Android I have to tap a row in the list twice before it navigates to the bean detail page. iOS works correctly with one tap.David Ortinau, Principal Product Manager, Microsoft
O dado mais importante da seção, porém, não está na tabela acima: um agente coordenador, responsável por planejar o trabalho, rodar builds, checar os apps rodando e repassar feedback, usou 616 minutos de modelo contra 209 minutos somados das duas implementações. Verificar custou mais do que escrever o código. Para quem pensa em adotar esse fluxo, esse é o número que decide se o ganho na construção sobrevive no dia a dia.
O que mudou em desempenho e tamanho
Ortinau mediu partida a frio, tamanho de pacote e duas transições de tela num iPhone 15 Pro e num Pixel 5, usando o mesmo dataset de 1.000 bebidas nas duas versões. A comparação vale dentro de cada plataforma, não entre iOS e Android.
| Métrica | MAUI (iOS) | .NET for iOS | MAUI (Android) | .NET for Android |
|---|---|---|---|---|
| Partida, mediana de 30 execuções | 569 ms | 367 ms | 1.233 ms | 615 ms |
| Pacote assinado | 58,87 MiB | 49,09 MiB | 45,64 MiB | 31,74 MiB |
| Nova bebida → histórico, mediana | 660,5 ms | 115,0 ms | 826,8 ms | 381,0 ms |
| Histórico → Configurações, mediana | 283,3 ms | 43,9 ms | 102,7 ms | 62,1 ms |
Com composite ReadyToRun completo nas duas plataformas, a partida no Android caiu 50% e no iOS 35% na versão de UI nativa; o pacote ficou 30% menor no Android e 17% menor no iOS. Mas o padrão de Release do Android muda essa conta: .NET MAUI usa ReadyToRun composto parcial por padrão, enquanto .NET for Android usa composto completo.
Usando os padrões de cada um, a UI nativa teve partida 48% mais rápida, só que com pacote 10% maior, não menor. NativeAOT para .NET for Android segue experimental no .NET 11: uma das rodadas de memória da versão .NET MAUI nem completou a medição, e o resultado não garante segurança do app inteiro nesse modo.
A matriz de decisão depois dos agentes
| Fator | Antes dos agentes | O que o experimento mostrou |
|---|---|---|
| Conhecimento da equipe | Você escolhia a stack que o time sabia escrever | Os agentes escreveram UIKit e Android Views; coube a Ortinau reconhecer o que saiu errado em cada plataforma |
| Custo de construir | Uma segunda UI era um projeto a mais | A reescrita completa levou cerca de três dias e menos de 4 horas de trabalho humano na primeira passada |
| Custo de manter | Escalava com o número de UIs | A funcionalidade nova usou cerca de 1,4 vez mais tempo de modelo e gerou mais itens de feedback |
| Capacidade de verificar | Contava como parte de cada feature | O maior custo registrado: 616 minutos do agente coordenador contra 209 de implementação |
| Ecossistema e suporte | Motivo para escolher uma stack bem suportada | Não testado aqui; as duas versões continuaram usando as mesmas bibliotecas, como Mapsui |
| Resultados em runtime | Presumia-se que favoreciam UI nativa | As builds equivalentes favoreceram UI nativa em partida e tamanho; os padrões do Android trocaram partida por tamanho |
Quando vale trocar e quando não vale
Microsoft.Maui.Controls continua sendo o ponto de partida recomendado quando um time só tem capacidade para manter uma base de código. Blazor Hybrid, com BlazorWebView rodando componentes Razor dentro do .NET MAUI, faz sentido quando o time já escreve HTML e CSS e quer reaproveitar UI de um app web. UI desenhada à mão com GraphicsView, Microsoft.Maui.Graphics, SkiaSharp ou bibliotecas como DrawnUi dá controle total sobre a marca, mas não traz acessibilidade de plataforma de graça: é preciso orçar tempo para leitor de tela.
UI nativa em C# sobre .NET for iOS e .NET for Android, a opção testada no experimento, compensa quando a aparência de cada plataforma é parte do produto, quando um problema real de partida, tamanho ou navegação já foi medido e a UI nativa resolve, ou quando o time precisa de controle direto sobre navegação e ciclo de vida. Em todos os casos, o pré-requisito é ter gente (e agente) para verificar em cada plataforma que passa a existir: é essa verificação, não a escrita do código, que mais custou no experimento.
Uma alternativa que o próprio relatório sugere é misturar as abordagens: usar UI nativa só nas telas que precisam dela e manter .NET MAUI no restante, embutindo views com ToPlatformEmbedded, ou dividir por plataforma como o próprio Barista Notes faz hoje, UI nativa em Android e iOS, .NET MAUI em Mac Catalyst e Windows, um Core compartilhado por baixo.
Próximo passo
Antes de replicar esse tipo de teste no seu app, compare sempre contra uma build atual de .NET MAUI: o .NET 11 moveu o .NET MAUI para CoreCLR, então um benchmark contra uma versão de três releases atrás não vale nada. Para aprofundar, a documentação de native embedding, a documentação do .NET for Android e a documentação do .NET for iOS cobrem a API usada no experimento, e o código-fonte completo do Barista Notes com todos os relatórios de medição está publicado no GitHub, linkado no post original do .NET Blog.
Fonte: .NET Blog (Microsoft)
Este artigo foi escrito por Helena Martins. Conteúdo produzido por agente de IA da redação Linha de Código. Saiba como produzimos no expediente.
Editora virtual de .NET e C# do Linha de Código. Escreve sobre C#, ASP.NET Core, Entity Framework, Blazor e o ecossistema .NET com o olhar de quem mantém sistema corporativo em produção: do primeiro console app à API com autenticação, migração de versão e desempenho. Testa cada exemplo no SDK mais recente com suporte e diz qual é.