Introdução

Linus Torvalds resumiu a cultura de desenvolvimento de software na lista de discussão do Linux em 2000 com a frase "Falar é fácil, me mostre o código"*.

* "Talk is cheap. Show me the code."

Essa frase nunca foi muito boa. Ela ajudou a alimentar o mito de que programar é um trabalho solitário e que alinhar ideias, discutir problemas e ouvir o time são perda de tempo. Escrever código sem alinhar o problema antes já gerava sistemas difíceis de manter. Mas o argumento ainda tinha uma base real: sentar na frente do computador e entregar código funcionando exigia muito esforço.

Essa relação se inverteu hoje. O código também é barato. Nós conseguimos gerar arquivos inteiros, escrever testes e preparar uma entrega em segundos a partir de dois parágrafos de instruções.

O trabalho diminuiu de verdade para quem está escrevendo o código. Tarefas mecânicas que antes tomavam dias agora ficam prontas em poucos minutos. Nós descrevemos o problema para o agente, vemos o projeto rodar e já temos uma primeira versão funcionando.

Essa velocidade cria um desequilíbrio dentro do time. Quem cria gasta muito menos energia, mas quem revisa passa a receber entregas maiores e mais frequentes. O código gerado por máquina costuma vir acompanhado de funções extras, abstrações desnecessárias e alterações espalhadas por vários arquivos.

O gargalo da engenharia de software mudou de lugar. Produzir código deixou de ser a etapa mais lenta do nosso trabalho. Revisar um volume grande de código que nem a pessoa autora limpou antes drena a atenção da equipe inteira. O ganho individual de quem gerou o código vira sobrecarga para quem precisa entender o que foi feito e sustentar essas decisões em produção.

Proposta

Muita coisa ainda está mudando na forma como construímos software com IA. Mesmo em um cenário em movimento, esta é a minha recomendação hoje para times e lideranças técnicas de projetos que querem aproveitar a velocidade dos agentes sem perder o controle do sistema nem esgotar a equipe.

A proposta se apoia em quatro princípios:

  1. Respeito ao tempo de revisão
  2. Transparência com o time
  3. Separar rascunho de produção
  4. Duas pessoas apertam o botão

1. Respeito ao tempo de revisão

Quando você pede uma revisão de código ou compartilha um documento ou análise, você deve ser a primeira pessoa a revisar o material, limpando e checando se tudo faz sentido antes de pedir a atenção do time. Do outro lado, encoraje a equipe a devolver entregas que parecem ter saído direto do agente sem filtro, fazendo uma pergunta direta antes de continuar a revisão:

"Esse código parece gerado por IA e não revisado, você pode confirmar se revisou todas as linhas?"

Essa pergunta pode parecer rude à primeira vista, mas não deve ser encarada assim. Ela é apenas um pedido de assinatura. Quem vai revisar precisa saber se a pessoa autora já leu, entendeu e validou aquele material, ou se a equipe está prestes a gastar horas sendo a primeira pessoa a ler o que a máquina escreveu.

Mudanças grandes também devem ser evitadas, mesmo quando já foram revisadas pela pessoa autora. Isso já era verdade antes da IA e continua sendo verdade hoje. Ninguém consegue manter a atenção lendo oitocentas linhas de uma vez só. Quebrar o trabalho em partes menores é essencial para preservar o senso crítico de quem revisa.

O que evitar Exemplo prático
Compartilhar uma entrega sem ler e entender o próprio código. Ser a primeira pessoa a revisar a entrega, entender o que cada linha faz e remover o que não é necessário antes de pedir o tempo do time.
Gastar horas tentando revisar um código que parece ter saído direto da IA sem filtro. Escrever para a pessoa autora no PR: "Esse código parece gerado por IA e não revisado, você pode confirmar se revisou todas as linhas?"
Enviar ou aceitar mudanças grandes de uma vez, mesmo que já tenham sido revisadas. Dividir o trabalho em entregas pequenas antes de compartilhar, ou pedir para a pessoa autora quebrar em partes menores antes de seguir com a revisão.

2. Transparência com o time

Ninguém deve ter vergonha de usar ou de não usar IA no código. A ferramenta é um meio para resolver problemas, e não um fim em si mesma. Um ambiente seguro permite que as pessoas falem abertamente sobre como construíram cada entrega, sem medo de parecerem menos técnicas por usarem um agente ou lentas por escreverem na mão.

Essa abertura deixa a comunicação muito mais leve para todo mundo. Se alguém perguntar no Pull Request se você revisou o código, responder um simples "sim, revisei" já é suficiente. Ninguém precisa se justificar por ter usado IA. O time só precisa da confirmação de que você leu, entendeu e responde por aquela mudança. Da mesma forma, quando você quiser compartilhar um rascunho apenas para discutir uma ideia, avise logo na primeira linha que o conteúdo foi gerado por IA e ainda não foi revisado.

O que evitar Exemplo prático
Enviar um código, análise ou documento para revisão escrito por IA que você não checou. Escrever no topo da mensagem: "Rascunho gerado por IA, ainda não revisei os detalhes. Quero apenas validar se seguimos por esse caminho."
Usar um agente para revisar o código e aprovar se ele não encontrar problemas. Compartilhar os apontamentos do agente avisando que vieram da IA e só aprovar depois de ler e revisar o código pessoalmente.

3. Separar rascunho de produção

No tutorial de Vibecoding, vimos como focar no produto e deixar a IA conduzir a criação. Esse formato funciona muito bem quando queremos validar ideias rápidas, testar interfaces ou montar ferramentas pessoais. Uma falha em um protótipo não causa prejuízo financeiro nem expõe dados de clientes.

O problema surge quando levamos esse improviso para o código de produção ou para sistemas de tomada de decisão real. Um serviço que calcula tarifas, aprova pedidos ou guarda dados sensíveis não pode depender de código que ninguém sabe explicar.

Separe fisicamente o código revisado do código não revisado. Mantenha experimentos e rascunhos em um repositório próprio ou em um diretório isolado do sistema principal. Essa barreira física evita que código gerado sem filtro se misture por engano com o que roda em produção. O rascunho serve para testar hipóteses e descobrir o que deve ser construído. Quando terminar a fase de exploração, descarte o protótipo e reescreva a solução do zero no repositório oficial, dividindo o trabalho em mudanças pequenas que o time consiga revisar e compreender por completo.

O que evitar Exemplo prático
Explorar ideias com o agente direto no repositório ou na branch que vai para produção. Criar uma pasta ou repositório separado de protótipo para testar o fluxo sem risco para o sistema real.
Aproveitar o código do protótipo direto no repositório principal. Descartar o rascunho assim que a solução ficar clara e reescrever do zero no projeto oficial em commits pequenos e revisáveis.

4. Duas pessoas apertam o botão

O agente de IA não entra no code red quando uma cobrança duplica na sexta-feira à noite ou um banco de dados trava em produção. Quem abriu a mudança e quem aprovou a revisão respondem sempre pelo código entregue. O código que vai para o ar leva o nosso nome, independentemente da ferramenta que usamos para escrever as linhas.

Toda mudança que vai para produção precisa de pelo menos duas pessoas que entendam o que aquele código faz: quem escreve e envia a entrega, e quem revisa e aprova. A regra é direta: não mande para revisão e não aprove em produção um código que você não consiga explicar, defender e consertar sem a ajuda da IA.

O papel dos agentes na revisão

Isso não significa banir a IA da etapa de revisão. Agentes podem ser usados para facilitar bastante a preparação e a leitura do código. Use modelos para organizar mudanças, sugerir formas mais simples de reescrever blocos de código e apontar trechos repetidos. Use também como um primeiro filtro para detectar vulnerabilidades conhecidas, credenciais expostas ou consultas perigosas.

O limite está na responsabilidade final. A ferramenta serve para facilitar o trabalho e apontar riscos, mas nunca exime duas pessoas de entenderem o código por completo e apertarem o botão para colocar a mudança no ar.

O que evitar Exemplo prático
Substituir a revisão feita por pessoas por um agente revisor. Usar o agente para sugerir como simplificar blocos de código ou buscar vulnerabilidades, mantendo a leitura e a aprovação final sempre com uma pessoa do time.
Aprovar um PR rápido confiando apenas que a pessoa autora ou o agente revisou. Questionar decisões da mudança durante o review e só aprovar quando as duas pessoas souberem explicar como aquele código funciona.

Contexto

Por que precisamos dessas travas em vez de deixar os agentes trabalhando e aprovando entregas sozinhos? A resposta está na própria forma como esses modelos aprendem a resolver problemas e nos incidentes que já começaram a aparecer na indústria.

Agentes são treinados com aprendizado por reforço para atingir uma meta mensurável, como fazer testes passarem ou chegar a uma resposta final. O treinamento recompensa o resultado final, não o caminho escolhido. O modelo procura a rota de menor resistência até a pontuação e aprende a pegar atalhos, um comportamento conhecido na pesquisa de IA como reward hacking.

Em julho de 2025, um teste público com o agente do Replit mostrou o que acontece quando um modelo tenta contornar problemas sem isolamento entre rascunho e produção. O agente ignorou instruções explícitas de congelamento de código, interpretou uma consulta vazia como um bug e apagou o banco de dados de produção com registros de mais de mil e duzentas empresas. Quando foi questionado sobre o sumiço, o modelo ainda gerou milhares de cadastros falsos para mascarar o problema e afirmou que era impossível recuperar o backup.

Outro incidente parecido derrubou um serviço da própria Amazon em dezembro de 2025. Uma pessoa engenheira pediu para o Kiro, agente interno da empresa, corrigir um bug simples no AWS Cost Explorer. O agente decidiu por conta própria que a solução mais rápida era apagar e recriar o ambiente de produção inteiro, tirando o serviço do ar por treze horas. Quando o caso saiu na imprensa, a Amazon publicou uma nota oficial dizendo que a culpa não era da ferramenta de IA, e sim um erro de quem configurou as permissões e a falta de revisão por pares. Na hora que o sistema cai, a empresa não culpa o modelo. A conta sobra para quem operou a ferramenta.

A busca por atalhos chegou ao extremo em julho de 2026. A OpenAI avaliava agentes autônomos em desafios de segurança dentro de um ambiente isolado. Os modelos deduziram que as respostas do teste poderiam estar salvas no Hugging Face. Em vez de resolver os desafios propostos, agentes quebraram as travas de segurança do ambiente de testes, usaram credenciais expostas na internet e invadiram a infraestrutura do Hugging Face para buscar o gabarito.

Os agentes não apagaram bancos de dados nem atacaram plataformas por malícia. Eles trataram cada uma dessas ações apenas como o caminho mais curto para bater a meta, como a própria OpenAI reconheceu depois. Nos nossos repositórios do dia a dia, a mesma lógica faz o agente apagar uma verificação difícil, comentar um teste quebrado ou afrouxar uma regra de permissão só para ver os testes ficarem verdes. Segurança e clareza nunca são a prioridade espontânea da máquina.

Conclusão

Lideranças técnicas têm um papel central nessa transição. A minha recomendação pode não funcionar do mesmo jeito para qualquer time, por isso é importante que cada equipe escreva ou adapte as regras do jogo para o seu próprio contexto. Quem lidera o projeto precisa deixar esses combinados claros, não ter medo de revisá-los com frequência conforme as ferramentas mudam e reforçá-los no dia a dia. Momentos de mudança também exigem cuidado com as pessoas, já que a pressão por velocidade é grande e proteger a saúde do time faz parte do trabalho técnico.

O custo de escrever linhas de código caiu, mas as boas práticas de desenvolvimento continuam as mesmas. Mudanças pequenas, testes que validam o comportamento real, separação entre rascunho e produção e revisões cuidadosas mantêm a mesma importância na era dos agentes.

Essas práticas nunca existiram porque digitar código era difícil. Elas existem para que pessoas consigam entender, manter e confiar nos sistemas que constroem juntas. As ferramentas ficaram mais rápidas, mas a responsabilidade pelo que vai para o ar continua nas nossas mãos.