Pular para o conteúdo principal
Voltar para Artigos

Integrando inovação e liderança em times mobile

Categoria
Liderança
Autor
Michel Lütz
Tópicos
Liderança de Engenharia, Arquitetura Mobile
Publicado originalmente em
Medium
Integrando inovação e liderança em times mobile: o texto de 2024, revisto em 2026.

Liderança técnica em mobile, de 2024 para 2026: contexto antes da arquitetura, documentação para o time e o agente, e por que o nativo voltou à mesa com a IA, no caso da Shopify.

A primeira versão deste texto saiu em 2024, no Medium, quando eu geria a engenharia mobile do Innovation Studio da Compass UOL. Ela fazia uma pergunta para quem desenvolve: até quando você quer continuar escrevendo a mesma tela, de novo e de novo? Em 2026, um agente de código escreve essa tela a partir do design. A pergunta continua valendo, só que agora para quem lidera.

Reescrevi o texto com o que mudou. O que não mudou é o que vem antes da ferramenta: contexto, documentação, um time que sabe quem decide o quê e uma arquitetura que aguenta mudança.

1. Mobile não é só mostrar dados na tela

Já vi projeto em que o mobile foi subestimado e virou só a tela que mostra o que o back-end manda. O equívoco aparece quando falta clareza, com o cliente e com as outras áreas, sobre o que torna um app difícil. Por isso, antes de qualquer decisão técnica, o líder técnico mobile precisa trazer para a mesa:

  • a usabilidade e a navegação de cada plataforma, que não são iguais;
  • as regras das lojas da Apple e do Google, que mudam o prazo de qualquer entrega;
  • os limites do aparelho: rede, bateria, memória e armazenamento;
  • o que acontece quando o app fica sem conexão.

A conversa entre os times de mobile, back-end e front-end também não pode ser formalidade. É ela que evita a surpresa no fim da sprint.

2. Contexto e negócio antes da arquitetura

Usar o que há de mais novo é tentador. Manter o pé no chão desde o início evita dor de cabeça depois. Um exemplo: nem todo projeto precisa começar modular. Três perguntas ajudam a decidir:

PerguntaPor que ela pesa
Todo o time conhece modularização de app?Se não conhece, o começo pede treinamento, e o prazo precisa contar com isso
Existe um roadmap claro de funcionalidades?Ele mostra o que o cliente planeja no curto e no médio prazo, e muda a separação de módulos, os componentes de base e os fluxos de navegação
Já existe um design system?Ele separa comportamento de estilo desde o início, mesmo sem modularizar

Não estou defendendo modularizar desde o começo, nem o contrário. A decisão tem variáveis que vão além da técnica, e quem lidera precisa colocá-las na mesa.

3. Nativo de novo: quando escrever código deixa de ser o gargalo

Eu me especializei em desenvolvimento nativo, e é o que eu mais gosto de fazer no mobile. Mesmo assim, em 2023, em Construindo Projetos Mobile Escaláveis, eu escrevi que, com pouco recurso e pressa, o multiplataforma era a melhor escolha, e que o nativo ganhava quando desempenho e experiência do usuário eram prioridade. Era uma conta de custo: dois apps nativos significavam escrever tudo duas vezes. Em 2026 essa conta mudou, e o caso mais claro é o da Shopify, que foi uma das maiores defensoras do React Native.

QuandoO que a Shopify disse ou fez
2020Apostou tudo no React Native, para parar de construir a mesma funcionalidade duas vezes
Jan. 2025Escreveu que o futuro do React Native era promissor e que seguiria investindo nele
Set. 2025Migrou o app Shopify e o Point of Sale para a nova arquitetura do React Native
Set. 2026Anunciou a volta ao nativo, em Swift e Kotlin, começando pelo app Shop, refeito em 12 semanas
Nov. 2026Contou como refez o app Shopify, com mais de 300 telas, de React Native para Swift e Kotlin em 12 semanas, com cerca de 30 engenheiros trabalhando em duplas

O motivo está no subtítulo do anúncio: "Coding agents changed what it costs to build mobile apps twice". Os agentes de código mudaram o custo de construir o app duas vezes. Em tradução livre, a explicação deles é que os agentes reduziram a vantagem de compartilhar a implementação, enquanto as vantagens de construir para cada plataforma continuam. No protótipo, um agente implementava no Android uma funcionalidade usando a versão de iOS como referência, e vice-versa.

O resultado, comparado com o app em React Native que eles tinham acabado de migrar para a nova arquitetura (abertura e memória pela mediana, o P50):

MedidaReact NativeNativo
Abertura do app no Android1,71 s0,87 s
Abertura do app no iOS0,70 s0,60 s
Tamanho do app Android80,4 MB47,6 MB
Memória no Android470 MB200 MB
Pico de memória no iOS730 MB190 MB
Sessões sem crash no Android99,66%99,98%

O que mais me interessa como líder não é o número, é como eles organizaram o trabalho. O código passou a ser escrito duas vezes, uma em Swift e outra em Kotlin, e os testes, uma vez só. A arquitetura que eles chamam de Reflex separa a lógica de cada tela num núcleo sem interface, com um contrato simples (ações entram, estado sai), que o agente constrói, testa e opera por linha de comando, sem emulador. Os mais de 1.700 testes de comportamento rodam em cerca de quatro minutos, nas duas plataformas.

%%{init: {"flowchart": {"nodeSpacing": 24, "padding": 10}}}%%
flowchart TD
    rfxT["Testes de comportamento<br/>escritos uma vez"] --> rfxI["Lógica da tela<br/>em Swift"]
    rfxT --> rfxA["Lógica da tela<br/>em Kotlin"]
    rfxI --> rfxIU["Interface<br/>iOS"]
    rfxA --> rfxAU["Interface<br/>Android"]

Duas frases do relato deles resumem a mudança. "Once writing code was no longer the slowest part of the system, the bottleneck moved": quando escrever código deixou de ser a parte mais lenta, o gargalo mudou de lugar. E "Agents do not magically produce good or bad software. They amplify the environment you put them in": o agente amplifica o ambiente em que você o coloca. Esse ambiente (arquitetura, testes, revisão) é responsabilidade de quem lidera.

Não é receita, e a própria Shopify diz isso. O nativo continua significando manter software em duas plataformas, e esse custo não sumiu. Eles também avisam que apontar um modelo para o código antigo e tentar gerar tudo de uma vez não funciona. E fecham dizendo que o React Native foi a escolha certa para eles em 2020. Para mim, que me especializei em nativo, é uma boa notícia com uma condição: o valor sai de escrever Swift e Kotlin e vai para desenhar uma arquitetura que o agente consiga construir e o time consiga verificar.

O que eu escrevi em 2024 continua valendo: dá para combinar as duas abordagens, com funcionalidades nativas numa base multiplataforma ou o contrário, e muitos clientes começam numa e precisam trazer partes da outra. A diferença é que, em 2026, o custo de escrever deixou de decidir sozinho.

4. Documente, e não se repita

Documentação é um tema recorrente para mim, e quem trabalhou comigo sabe como insisto nele. Não é tarefa só do time ou do líder técnico: é uma prática que a liderança incentiva e todo mundo pratica. Time e funcionalidade mudam o tempo todo, e repassar conhecimento custa caro.

O DRY (Don't Repeat Yourself) vale também para as explicações. Em vez de repetir o mesmo onboarding e o mesmo refinamento, grave vídeos curtos sobre cada funcionalidade e sobre cada definição técnica, e ligue a transcrição. Esse acervo vale muito mais tarde (a seção 9 mostra como).

Se você cair num projeto pouco documentado, comece pelo básico: uma reunião com as pessoas-chave, anotações e um primeiro desenho de arquitetura de referência, compartilhado num lugar que o time inteiro abre, como Confluence ou SharePoint. O começo é tedioso. Ver o progresso a partir do zero compensa.

Em 2026 a documentação ganhou um leitor novo: o agente de código. A especificação escrita antes é o que o time e o agente leem, e é a ideia por trás do Spec-Driven Development, com que trabalhei no ciclo de desenvolvimento e sobre o qual escrevi em Spec-Driven Development no Mobile.

5. Conheça o time e divida responsabilidades

Construir relação com as pessoas, e deixar que elas conheçam você, cria confiança dentro do time. Todo mundo tem lacunas, e mapear essas lacunas desde o início é parte do projeto. Incentive uma cultura em que as pessoas se sintam à vontade para dizer que não dominam algo e para pedir apoio. Escrevi sobre isso em Um líder técnico não precisa saber de tudo.

Dividir e delegar para as pessoas certas muda o resultado do projeto. Deixe a divisão clara para o seu time e também para as outras lideranças, em especial quando o projeto envolve mais de um squad. Essa transparência evita conflito e mal-entendido no caminho.

6. Princípios de arquitetura para apps

Um app que aguenta mudança separa as camadas e deixa claro quem fala com quem:

%%{init: {"flowchart": {"nodeSpacing": 24, "padding": 10}}}%%
flowchart TD
    arqU(["Usuário"]) --> arqP["Apresentação<br/>telas e lógica de tela"]
    arqP --> arqN["Negócio<br/>fluxos, componentes<br/>e entidades"]
    arqN --> arqD["Dados<br/>acesso local e cache"]
    arqD <--> arqR["Infraestrutura remota<br/>serviços e sincronização"]

Configuração, segurança e comunicação atravessam as camadas. Os princípios que eu uso para avaliar uma arquitetura mobile:

PrincípioNa prática
Separação de responsabilidadesInterface, regra de negócio e acesso a dados em partes distintas, cada uma com uma responsabilidade clara
DesacoplamentoPoucas dependências entre as partes, para cada uma ser desenvolvida, testada e mantida sozinha
ReaproveitamentoComponentes e bibliotecas compartilhados. Comece simples, refatore quando precisar e não escreva código que ninguém vai usar
EscalabilidadeEspaço para crescer em usuários e em funcionalidades, com uso eficiente de rede e de hardware
TestabilidadeComponentes fáceis de testar e testes automatizados desde o começo
ManutenibilidadeAchar e corrigir problema rápido. Biblioteca para tudo nem sempre ajuda: pese as privadas contra as da comunidade
DesempenhoLembrar que muitos aparelhos têm pouca rede e pouco armazenamento: menos memória, menos tempo de carga e menos dados trafegados

7. IA e mobile: o que eu escrevi em 2024 e o que eu acrescento hoje

Em 2024 eu listei oportunidades de IA em apps. Elas continuam de pé. O que eu acrescento em 2026 é o cuidado que cada uma pede:

Em 2024 eu sugeriEm 2026 eu acrescento
Personalizar a experiência: o app aprende com o uso e reorganiza os menusMostrar ao usuário o que o app aprendeu e como desligar
Automatizar tarefas repetitivas, como anotações e pagamentosComeçar pelas tarefas do próprio time de engenharia, onde o erro custa menos
Acessibilidade avançada, com descrição de imagensTestar com quem usa leitor de tela: a descrição automática ainda erra
Orientação de saúde e bem-estarTratar dado de saúde como dado sensível, com a LGPD na mão
Visão computacional e OCRProcessar no próprio aparelho quando o dado é sensível

Do lado do desenvolvimento, eu propus em 2024 uma ideia que parecia distante: a partir do design feito pelo time de experiência do usuário, a IA reconhece os elementos da tela, busca numa base de componentes o que precisa e escreve o código da tela no padrão do projeto. Bastaria ligar as camadas e as regras de negócio. Eu escrevi que, com um projeto bem estruturado e a documentação em dia, isso era factível. Este foi o exemplo que me inspirou na época:

Hoje um agente faz isso, como a seção 3 mostrou com a Shopify. O peso mudou de lugar: saiu do código da tela e foi para o trabalho em volta dele. Decidir o que vai para o agente, quem revisa o que ele escreve e como saber se a qualidade se manteve é trabalho de liderança. Medi o custo disso na arquitetura do app em Quanto custa a arquitetura do seu app para um agente de IA.

8. Ética e privacidade

Os desafios técnicos de implementar IA existem com ou sem IA. Os de ética e de privacidade pedem atenção dobrada. O pedido de permissão precisa ser claro. O usuário precisa saber que dado o app coleta e para quê, de acordo com a LGPD. E é preciso cuidado com o que se compartilha nos ambientes de desenvolvimento, inclusive com as ferramentas de IA do próprio time.

9. Dados para decidir

Lembra das gravações e das transcrições da seção 4? Com um código simples e um banco vetorial, elas viram uma base de conhecimento do projeto: dá para buscar por significado, e não só por palavra, em transcrições, PDFs e markdown.

%%{init: {"flowchart": {"nodeSpacing": 24, "padding": 10}}}%%
flowchart TD
    dadA["Gravações de reuniões,<br/>refinamentos e chapters"] --> dadB["Transcrições"]
    dadB --> dadC["Embeddings"]
    dadC --> dadD["Banco vetorial"]
    dadD --> dadE["Busca semântica:<br/>o time pergunta,<br/>a base responde"]

Com essa base, o time acha lacunas do projeto, as bibliotecas em uso e as regras de negócio já discutidas, e evita retrabalho. Escrevi uma demo em Python com busca semântica sobre os chapters técnicos do Innovation Studio, e é impressionante o que sai dessas conversas gravadas. O vídeo que mostra a técnica, com LangChain e embeddings, é este:

Para o produto, a análise de dados segue um roteiro simples:

PassoO que fazer
ContextoEntender os objetivos do projeto antes de escolher métrica
MétricasEscolher as que importam: tempo de sessão, retenção e conversão, e também tempo de carga e taxa de falha
FerramentasFirebase Analytics, Google Analytics e as métricas das lojas; DataDog e New Relic, que muita gente usa só em serviços, mostram muito da saúde do app
IteraçãoUsar o que os dados mostram para priorizar e ajustar a estratégia

Para consolidar relatórios, uso muito o pandas, do Python: um dataframe junta fontes diferentes, a documentação é boa e a comunidade é grande.

O que continua em aberto

  • Onde a revisão humana continua obrigatória quando um agente escreve a tela?
  • Como documentar para o time e para o agente ao mesmo tempo, sem escrever duas vezes?
  • Que métrica mostra que a IA melhorou o trabalho do time, e não só a velocidade?

Se o seu time já gera tela com agente, me conte o que mudou na revisão. A conversa continua no LinkedIn.

Leia também

Referências

Tags

  • lideranca-tecnica
  • mobile
  • nativo
  • arquitetura
  • ia
  • documentacao
  • spec-driven-development