English summary: AI changed how we write code, but also shifted the role of testing. Understand why test pyramids and trophies now serve as reward functions for AI agents, with real examples using TypeScript, Vitest, and Playwright.

Testes na Era AI-Native: O Código que Avalia o Código

A IA generativa prometeu nos libertar da escrita de boilerplate. O que muita gente não percebeu é que, ao terceirizar a geração de código para um modelo estatístico, você não eliminou o problema da confiabilidade; você apenas o moveu de lugar.

Em um ambiente AI-Native, onde agentes escrevem, refatoram e integram features, o teste deixou de ser apenas uma rede de segurança para o humano. Ele se tornou a especificação exata, o limite e a função de recompense (reward function) do próprio agente.

Sem uma arquitetura de testes rigorosa, agentes entram em loops infinitos, quebram regressões silenciosamente e entregam "alucinações" empacotadas como features.

A Evolução: Pirâmide, Troféu e Evals

Historicamente, nos apoiamos em modelos visuais para distribuir o esforço de testes:

A Pirâmide de Testes (Martin Fowler):
Focada em uma base massiva de testes unitários rápidos e isolados, com poucos testes E2E no topo. Excelente para lógica determinística, mas muitas vezes frágil a refatorações internas.
O Troféu de Testes (Kent C. Dodds):
Focado no "meio" do funil — os testes de integração. Segundo Kent, "escreva testes, não muitos, a maioria de integração". Essa abordagem ganhou tração no ecossistema front-end porque testa o componente da forma como o usuário interage com ele.
O Novo Paradigma: Eval-Driven Development:
Com agentes construindo features inteiras, a pirâmide e o troféu não perdem o valor; eles se tornam o ground truth (verdade fundamental) para Evals (avaliações).
Um Eval de um agente é essencialmente uma pergunta: "O código gerado resolve o problema sem quebrar o sistema?". A única forma computacional e determinística de responder isso é passando por uma suíte de testes impiedosa.

O Papel do Unitário (Vitest) e do TypeScript

Modelos de linguagem são ótimos em gerar abstrações, mas péssimos em garantir contratos estritos se não forem guiados. O TypeScript é a primeira linha de defesa — o compilador é o teste unitário mais rápido que existe.

Quando a IA gera lógica de negócio, o teste unitário com Vitest valida se a heurística matemática ou o parsing de dados não foi corrompido por uma "adivinhação" do LLM.

// math-parser.ts
export function parseExpression(expr: string): number {
  // Código gerado por AI...
}

// math-parser.test.ts
import { expect, test } from 'vitest';
import { parseExpression } from './math-parser';

test('garante que a IA não quebrou a ordem de precedência', () => {
  // Para um LLM, "2+2*2" pode ser confuso dependendo do contexto estatístico.
  // O teste fixa o contrato de comportamento:
  expect(parseExpression('2+2*2')).toBe(6);
});

Aqui, o Vitest atua como o "guardrail" determinístico do agente. Se o subagent tentar refatorar a performance desse parser e quebrar a precedência matemática, o Vitest barra o merge imediatamente.

O Papel do E2E (Playwright)

Se o unitário garante a peça, o End-to-End garante a jornada. Na era AI-Native, interfaces inteiras são construídas de forma declarativa e dinâmica (ex: vibe coding ou UI-as-Code). O Playwright testa a experiência do usuário da forma mais real possível.

// login-flow.spec.ts
import { test, expect } from '@playwright/test';

test('agente não quebrou o fluxo crítico de conversão', async ({ page }) => {
  await page.goto('/login');
  
  // A IA pode ter mudado o layout ou o CSS, mas os contratos de acessibilidade (roles) devem se manter.
  await page.getByRole('textbox', { name: /email/i }).fill('user@lemon.dev.br');
  await page.getByRole('button', { name: /entrar/i }).click();

  // Valida o estado real no DOM
  await expect(page.getByRole('heading', { name: /dashboard/i })).toBeVisible();
});

A resilyência dos seletores baseados em acessibilidade (como getByRole) é vital. Se a IA recriar o botão mudando de uma tag <button> para um div mal feito, o Playwright captura a falha semântica, forçando a IA a consertar.

Evals: O Loop de Feedback Autônomo

Na Anthropic em projetos maduros que utilizám Claude Code, os Evals são as métricas que decidem se uma feature está "pronta".
Um pipeline de Eval-Driven Development funciona assim:

O agente recebe a tarefa e o contexto.
O agente gera o código.
O pipeline roda: tsc --noEmit (tipagem) -> vitest run (lógica) -> `playwright test`` (jornada).
O stdout (saída de erro) volta diretamente como prompt para o agente: "Sua alteração falhou no teste X. A causa raiz parece ser Y no componente Z. Corrija."

Sem esses testes, o agente ficaria cego. Ele dependera de inspeção humana para cada refatoração trivial.
Com testes rigorosos, você permite que agentes operem com um raio de explosão (blast radius) controlado.

Conclusãoo

Testes bem escritos nunca foram tão valiosos. Na era do desemvolvimento com IA, a vantagem competitiva nÃà ù quem gera código mais rápido, mas quem consegue verificar código mais rápido.

As ferramentas (TypeScript, Vitest, Playwright) j�á estão aá. A diferença é que antes elas dizem a você onde você erou. Hoje, elas dizem ao seu agente de IA como continuar trabalhando de forma segura. E é isso que escala a engenharia para o próximo nível.