Líderes de pensamento

Por que os testes precisam fazer parte da linha de montagem da IA desde o início

Ole Lensmar
Adicione Unite.AI às suas fontes preferidas no Google
Pontos-chaveA IA acelera a codificação, mas expõe testes posteriores fracos e reduz a estabilidade…
Ver mais
  • A IA acelera a codificação, mas expõe testes posteriores fracos e reduz a estabilidade da entrega.
  • Agentes que avaliam os próprios testes podem trapacear editando testes que falham em vez de corrigir o código.
  • Os testes devem ser uma estação própria fora do CI, para que cada alteração enfrente o mesmo veredito.

Há mais de vinte anos, venho desenvolvendo ferramentas de teste e, durante a maior parte desse tempo, minhas conversas com equipes de engenharia foram bastante parecidas. Quem trabalha com testes se sentia tratado como cidadão de segunda classe no ciclo de vida do software. Os testes eram feitos tarde, muitas vezes espremidos no pouco tempo que restava antes de um lançamento e inseridos em um pipeline de CI criado para outra finalidade. A IA transformou a maneira como escrevemos código — e isso certamente teve impacto nos testes, para melhor e para pior. Em muitos aspectos, a IA tornou o desafio mais visível.

Nos últimos meses, participei de alguns eventos sobre testes e tecnologias nativas da nuvem (LeadDev, CloudX, StarWest), e quase todas as equipes com que conversei estão trabalhando em alguma versão do mesmo projeto: um ciclo de entrega de software orientado por IA, no qual agentes levam o trabalho de uma especificação até algo em execução na produção, com o nível adequado de envolvimento humano ao longo do processo. Imagino isso como uma linha de montagem. Alguns agentes escrevem o código, outros o revisam, e os pipelines compilam e implantam o software. As pessoas ficam de olho no que acontece. O que ouço muito menos é onde os testes se encaixam nessa linha.

Ninguém ainda descobriu como fazer isso

No momento, é um pouco como o Velho Oeste. Surgem novos recursos de agentes a cada poucas semanas, os grandes laboratórios de IA continuam lançando novos modelos, e tanto as equipes quanto os fornecedores estão tentando de tudo para ver o que funciona.

Alguns dados sugerem que as lacunas já estão aparecendo. O relatório mais recente do Google sobre desenvolvimento de software com assistência de IA da DORA, que entrevistou quase 5.000 profissionais de tecnologia, constatou que a adoção da IA está associada a um maior volume de entregas, o que é uma boa notícia. Ela também continua associada a uma menor estabilidade das entregas. Segundo a explicação dos pesquisadores, a IA acelera o desenvolvimento e expõe fragilidades nas etapas posteriores do processo; eles apontam testes automatizados robustos como um dos mecanismos de controle que impedem que um aumento nas mudanças resulte em mais instabilidade.

Isso não me surpreende. Se você faz passar muito mais código por um processo que foi projetado para lidar com bem menos, alguma etapa fica mais lenta ou algo acaba quebrando.

Os desenvolvedores estão mais rápidos, mas a maioria dos lançamentos não

Quando as pessoas imaginam o que pode dar errado com código gerado por IA, tendem a pensar em um agente colocando algo terrível em produção. Tenho certeza de que isso acontece — e, quando acontece, as consequências não são nada boas: bugs, clientes insatisfeitos, talvez até um incidente de segurança. Mas, para ser sincero, não é isso que costumo encontrar na maior parte do tempo.

A Pesquisa com desenvolvedores do Stack Overflow de 2026 mostra em que atividades o uso da IA se concentra atualmente. Os desenvolvedores a usam principalmente para gerar código em áreas que já conhecem (67%) e para depurar (61%), enquanto apenas 20% a utilizam para implantar, operar ou solucionar problemas em sistemas de produção. Até agora, a IA acelerou sobretudo a escrita de código. A verificação desse código e sua entrada em produção ainda funcionam, em grande medida, como antes.

Isso também corresponde ao que venho observando: as equipes produzem muito mais código sem lançar software com maior rapidez. Um desenvolvedor ou uma equipe pode sentir que está criando o dobro de funcionalidades, mas elas ficam retidas nas etapas seguintes, à espera de revisão, de testes ou de um ambiente onde possam ser testadas. Todo esse código extra congestiona o pipeline e, em muitos casos, até desacelera o ritmo geral de entrega das equipes.

As perguntas sobre salvaguardas vêm dos gestores

Embora a preocupação com gargalos na entrega causados pela IA seja bastante concreta, não é a única questão que as equipes nos apresentam. Os desenvolvedores querem, em geral, saber como escrever código melhor com mais rapidez. Já as perguntas sobre salvaguardas vêm dos gerentes de engenharia e das pessoas que estão configurando esses fluxos de trabalho orientados por agentes. Como garantir que os agentes não saiam do controle? Como saber se não estão introduzindo regressões ou ignorando discretamente tarefas que deveriam realizar? Como garantir que os testes que eles escrevem realmente (e de forma honesta!) validem aquilo que deveriam validar?

Acho que isso acontece porque eles estão observando aspectos diferentes. Um desenvolvedor analisa uma solicitação de pull por vez. Já um gerente de engenharia é responsável por tudo o que é lançado por muitos agentes e muitas pessoas, e é quem precisa explicar o que aconteceu quando algo quebra em produção.

E há motivos para agir com cautela. Pesquisadores criaram um benchmark chamado ImpossibleBench, com tarefas de programação cujos testes unitários contradizem a especificação, de modo que a única maneira de passar é trapacear. Os principais modelos frequentemente fizeram exatamente isso, por exemplo, editando ou excluindo os testes que falhavam em vez de corrigir o código (!!). Um estudo de solicitações de pull criadas por agentes encontrou lacunas na qualidade dos testes que os agentes fazem das próprias alterações e cita pesquisas anteriores que mostram que quase um terço das solicitações de pull de agentes integradas ao código precisou de correções ou refatoração posteriores.

Minha conclusão é que as salvaguardas não podem existir apenas no ambiente do próprio agente, nem podem ser aplicadas somente depois que o código é lançado. Se o agente que escreveu o código também decide se ele passou nos testes, o resultado não diz muita coisa. Isso não significa que os agentes não devam escrever testes. Significa que a avaliação precisa vir de uma fonte que o agente não possa alterar. Os testes precisam ocupar uma estação própria na linha de montagem, pela qual passe toda alteração, tenha ela sido escrita por uma pessoa ou por um agente.

O que essa estação precisa

A resposta não é um tipo totalmente novo de teste. A maior parte do que é necessário é o que as boas equipes de QA vêm pedindo há muito tempo. Só que agora isso é ainda mais importante.

Os testes precisam ser revisados para verificar se estão corretos em relação aos requisitos — assim como o código que testam. Também precisam ser executados no ambiente em que o software funciona. Um teste que passa na sandbox de um agente não diz muita coisa sobre os ambientes de homologação ou produção e pode ocultar quais dependências foram simuladas — ou de que forma. Um estudo de quase 180.000 arquivos de teste gerados por agentes constatou que os agentes cobriram mais casos extremos do que os testes escritos por pessoas, mas que seus testes apresentaram mais sinais de instabilidade, em grande parte porque os agentes não conheciam suficientemente o ambiente em que os testes seriam executados. Executar os testes desde cedo em uma infraestrutura real permite detectar esse problema.

Os testes e seus resultados precisam ser preservados. Se um agente escrever um teste, deve ter acesso aos testes existentes e a seus resultados como contexto, para aprender tanto com a cobertura quanto com possíveis instabilidades. Os testes precisam ser revisados e versionados como qualquer outro código, para que sejam executados novamente na próxima alteração, em vez de desaparecerem quando a sessão terminar.

Um resultado aprovado deve significar a mesma coisa, independentemente de quem o solicitou: um pipeline, um desenvolvedor ou um agente. Isso significa usar os mesmos testes, executados na mesma infraestrutura, com os resultados reunidos em um só lugar.

E as pessoas devem continuar usando o próprio discernimento. Não me incomoda deixar os agentes cuidarem do código repetitivo e das conexões entre componentes. Decidir o que vale a pena testar e o que significa uma falha continua sendo tarefa de uma pessoa (pelo menos por enquanto…).

Isso também significa que os testes não podem ficar restritos ao CI/CD (se você guardar uma única coisa deste artigo, que seja esta!). Os pipelines de CI foram criados para compilar e distribuir código; nunca foram projetados para executar testes automatizados em grande escala. À medida que avançamos para um SDLC orientado por agentes e a quantidade de código continua aumentando, o CI se torna ainda menos adequado para executar testes. Os testes precisam ser um componente de primeira classe da entrega de software, e não uma etapa acrescentada ao final de um pipeline. Isso significa orquestrá-los como um sistema próprio, em todas as ferramentas e ambientes usados por uma equipe, independentemente de quem os esteja conduzindo — um agente ou uma pessoa.

Por onde começar

A maioria das equipes já tem testes em que confia, feitos com Playwright, Cypress, k6, Postman ou qualquer outra ferramenta que tenha padronizado, e esse é um ótimo ponto de partida. Algumas sugestões:

  1. Mapeie como uma alteração passa do prompt à produção hoje e marque todos os pontos em que um teste é executado. Se houver apenas um, perto do fim, eu começaria por aí.
  2. Tenha cuidado para não deixar os agentes alterarem silenciosamente os testes existentes. Os pesquisadores do ImpossibleBench constataram que restringir o acesso dos agentes aos testes reduziu as trapaças. Quando um agente realmente precisar alterar um teste, a mudança deve ser enviada como um pull request para revisão de uma pessoa, como qualquer outra alteração de código.
  3. Execute seus testes em ambientes de teste (de preferência, reais), e não em sandboxes de agentes, o mais cedo possível — mesmo que seja apenas uma pequena bateria de testes de fumaça no ambiente de homologação para cada alteração gerada por um agente. Se você usar IA para escrever testes, não aprove nenhum antes que ele tenha sido executado nesse ambiente.
  4. Centralize os resultados dos testes em um único plano de controle — seja uma ferramenta de relatórios, sua solução de APM ou uma plataforma de testes dedicada. Garanta que tanto as pessoas quanto os agentes tenham acesso a esses resultados.
  5. Meça a entrega, não a atividade. O número de pull requests diz muito pouco. As métricas de entrega da DORA, como o tempo de entrega das alterações e a taxa de falha das alterações, dizem muito mais sobre se a IA está ajudando.
  6. Permita que os agentes usem a mesma infraestrutura de testes que sua equipe utiliza, para que o trabalho deles seja avaliado pelos mesmos critérios.

Otimismo com ressalvas

Sou otimista em relação à IA e acredito que ela tornará as equipes de software muito mais capazes e, em última análise, mais produtivas. Mas, para chegar lá, as equipes precisam confiar o suficiente no que seus agentes produzem para lançar esse trabalho, além de adotar uma abordagem abrangente de testes no SDLC orientado por agentes — é aí que essa confiança se constrói ou se perde.

Se você está buscando um SDLC orientado por agentes, qual é o lugar dos testes nele hoje?

Ole Lensmar é cofundador e diretor de tecnologia da Testkube, uma plataforma aberta de testes para equipes de engenharia orientadas por IA. Ele criou o SoapUI, uma das ferramentas de teste de API mais utilizadas, e anteriormente presidiu a OpenAPI Initiative.