- TDD
- test driven development
- red green refactor
- testes unitários
- qualidade de software
- IA no desenvolvimento
- vibe coding
- mutation testing
- clean code
- workflow de desenvolvimento
- AI code generation
Minha Jornada com TDD
Do Caos ao Código Que Funciona de Primeira
Já perdi a conta de quantas noites passei debugando algo que um teste de cinco minutos teria pego antes. Todo desenvolvedor conhece essa sensação, mas pouca gente admite. Minha relação com testes começou como a de quase todo mundo: escrever o código primeiro e depois encaixar testes onde dava. Até descobrir que dava para inverter essa ordem. Neste post eu conto como saí de um fluxo caótico e reativo para um processo em que o código funciona de primeira: o que me fez tentar TDD, onde eu travei, o momento em que fez sentido e o que aprendi aplicando no dia a dia, inclusive com IA.
Como Eu Desenvolvia Antes do TDD
Meu fluxo seguia um padrão que eu via em todo lugar: escrever todo o código, refatorar para deixar legível e só então tentar gerar testes. O problema aparece quando você para para pensar. Testar código pronto é muito mais difícil do que parece, porque ele passa por tantas mudanças até a versão final que mapear todos os cenários vira um exercício de adivinhação.
E os testes manuais continuavam, mesmo depois que eu escrevia os automatizados. Na prática, eu tinha dois fluxos de validação em paralelo, e nenhum dos dois me dava confiança.
A IA deixou o problema mais visível
Com a popularização da IA generativa para código, isso ficou ainda mais evidente. A IA gerava testes, mas de um jeito permissivo demais: ela alterava o teste para ele passar no código existente, em vez de fazer o código se adaptar ao teste. Isso criava uma falsa sensação de segurança, que só aparecia quando eu rodava mutation testing e via mutantes sobrevivendo com frequência.
O ciclo era sempre o mesmo: código funcionando na minha máquina, testes passando e produção explodindo. E eu achando que o problema era eu. Foi essa frustração que me levou a procurar outro caminho.
O Que Me Fez Tentar TDD (e Onde Eu Travei)
A virada começou quando vi o Akita falando sobre desenvolvimento com IA. Uma ideia dele ficou na minha cabeça: vibe coding é ruim, mas IA com TDD vira um game changer.
No início eu resisti. Conhecia TDD só de nome. Escrever um teste antes de existir qualquer código parecia absurdo: como testar algo que não existe?
Mas a frustração com os bugs era maior que o ceticismo. Então comecei a estudar. Li sobre o ciclo Red-Green-Refactor, vi exemplos e entendi a teoria. Mesmo assim, quando fui aplicar pela primeira vez, travei de novo.
A maior dificuldade: granularidade
O que ninguém explica com clareza é quanto escopo colocar em cada ciclo de TDD. Uma tela inteira? Uma micro função? Um grupo de funções relacionadas?
Pesquisei bastante e não encontrei nada conclusivo. A literatura fala em "unidades pequenas", mas não diz o que isso significa na prática. Então descobri testando:
- Telas inteiras: não funcionou. O escopo era grande demais, o teste ficava frágil e qualquer mudança quebrava tudo.
- Grupos de funções: melhorou, mas eu ainda testava coisas demais ao mesmo tempo.
- Micro funções: aqui fez sentido. Testes de coisas específicas, como "tentar deletar uma tabela sem ser admin" ou "tentar listar dados de outro usuário usando o ID direto". Pequenos, focados e independentes.
Não é necessariamente a resposta certa para todo mundo. Foi a que funcionou para mim, e levei um tempo até chegar nela. Com a granularidade resolvida, faltava colocar o ciclo para rodar num projeto inteiro.
Red, Green, Refactor: Os Primeiros Ciclos
Meu primeiro projeto com TDD foi pessoal, feito justamente para treinar a metodologia: um AI RPG Master usando o sistema Fate. Aqui, o que importa é o aprendizado.
O backend dessa aplicação ficou com mais de 500 testes unitários, todos seguindo o fluxo do TDD: primeiro o teste, depois a função. O teste falha, o código passa, eu refatoro. E repito.
Como a IA entra nesse ciclo
Minha integração com IA nesse processo não é vibe coding. Uso IA há mais de um ano de forma pragmática, com planejamento, PRD, entendimento profundo dos requisitos e agentes especializados para code review, segurança e acessibilidade. A IA executa o que eu penso. A cabeça sou eu. Detalhei esse fluxo em meu fluxo de desenvolvimento com IA.
Para aprender TDD, não foi diferente. Criei um agente especialista em TDD que executa o ciclo Red-Green-Refactor de forma automática. Cada função é uma sessão nova, com contexto zerado, porque as funções precisam ser independentes. Planejo exatamente como aquela função vai funcionar, executo o ciclo e só depois começo a conectar as funções.
O ciclo ainda não é natural
Uma ressalva importante: o Red-Green-Refactor ainda não é natural para mim. Ainda estou me acostumando, e várias vezes sinto que estou mais lento do que antes. Essa percepção muda com o tempo, e o que me fez mudar de ideia foi um teste específico.
O Momento em Que Tudo Fez Sentido
Quando terminei o backend do AI RPG Master, com os mais de 500 testes unitários, eu ainda não tinha sentido o valor daquilo. Não tinha rodado a aplicação. Era só uma pilha de testes passando no terminal.
Aí rodei um teste end-to-end. Passou de primeira.
Sem refatorar nada depois, sem descobrir uma falha aqui e outra ali, sem ajustar durante o fluxo. Isso nunca tinha acontecido comigo. Eu sempre achava algo para corrigir depois, sempre tinha um bug escondido esperando a pior hora para aparecer.
Foi ali que percebi que valia a pena. E não só porque funcionou de primeira, mas pela confiança que isso gera: saber que o código está coberto, que cada cenário foi pensado antes de existir, que o teste é a âncora e o código é que se adapta a ele.
É dessa memória que eu lembro quando o ciclo parece lento e a fricção aparece. Ela também explica por que, para mim, TDD e IA andam juntos.
TDD com IA: Por Que Vibe Coding Não Funciona
O problema do vibe coding não é a IA. É a ausência de validação. Quando você pede código para a IA sem ter testes definindo o que é correto, está confiando que o modelo entendeu a sua intenção. E isso raramente acontece de forma consistente.
Vi várias vezes a IA alterar o mesmo teste repetidamente até ele passar. E percebi a vulnerabilidade quando rodei mutation testing: os mutantes sobreviviam porque o código não estava bem construído, e a IA ajustava o teste para se encaixar no código errado. Quando você inverte essa lógica, o cenário muda:
"Agora tenho um teste correto que define o comportamento esperado. Se o código gerado pela IA não passa no teste, quem precisa mudar é o código. Não o teste."
Como eu controlo a IA
Para isso funcionar, preciso ser rígido com os agentes. Cada agente tem uma lista clara do que pode e do que não pode fazer: "não faça isso sob hipótese nenhuma", "você só faz isso e nada além". Sem essa disciplina, a IA sai gerando código aleatório e o ciclo de TDD perde o sentido.
Por curiosidade, já analisei aplicações feitas com vibe coding e consegui acesso total a mais de uma. Isso não é exceção, é consequência de não ter validação. Quem é júnior e entende a lógica por trás do código já está um passo à frente. Mas é TDD com IA que separa quem usa a ferramenta com segurança de quem só sai pedindo coisas.
Depois de meses aplicando isso, algumas lições ficaram claras.
O Que Aprendi Sobre TDD na Prática
Uso TDD há meses em projetos novos, pessoais e de clientes. Estas são as quatro coisas que mais mudaram a minha visão.
O código fica mais enxuto
Isso me surpreendeu. A fase green, em que você escreve o mínimo de código para o teste passar, previne over engineering naturalmente. Como já existe um teste dizendo o que eu espero, escrevo só o suficiente para aquele cenário. O resultado são funções menores e mais diretas, com muita qualidade. Código que faz exatamente o que precisa, nem mais nem menos.
A sensação de lentidão é real no começo
No início, TDD parece mais lento. E é comum: você está aprendendo uma metodologia nova, quebrando hábitos antigos e pensando de outro jeito.
Minha recomendação é documentar o processo. Anote quantas refatorações você fazia antes, quanto tempo levava para implementar uma funcionalidade e quantos bugs apareciam depois. Depois compare com os números usando TDD. Com dados na mão, fica claro que no fim você teve menos trabalho, mesmo que a sensação inicial tenha sido de mais esforço.
Os estudos industriais vão na mesma direção. Em um estudo com três times da Microsoft e um da IBM, pesquisadores da Microsoft Research, da IBM e da NC State viram a densidade de defeitos antes do lançamento cair entre 40% e 90% em comparação com projetos parecidos sem TDD. Em troca, os times relataram um aumento de 15% a 35% no tempo inicial de desenvolvimento. Na minha experiência, esse tempo volta com sobra no debugging que deixa de existir.
TDD não é para todo mundo, e tudo bem
Essa é uma opinião impopular, mas eu acredito nela: TDD não deveria ser obrigatório. É uma escolha pessoal.
Existem várias metodologias: TDD, Spec Driven Development e outras. Cada pessoa deve usar a que funciona melhor para ela, desde que o resultado fique dentro do padrão da equipe. Obrigar alguém a seguir uma metodologia limita o potencial dessa pessoa.
O que eu defendo é que todo mundo teste metodologias diferentes. Eu vinha do Spec Driven Development, e ele funcionava bem, mas eu me sentia travado. Ao testar TDD, percebi que era o que mais combinava com o meu jeito de trabalhar. A única forma de saber o que funciona para você é experimentando.
Em sistemas legados, aos poucos
Essa é uma pergunta que recebo bastante. A resposta é: gradualmente. Não fui atrás de aplicar TDD nos sistemas legados da empresa. Mas, quando chega uma micro demanda que se encaixa bem, aplico TDD nela e garanto o funcionamento daquela parte.
Com o tempo, isso gera confiança para mexer em código existente, porque você sabe que os testes protegem o comportamento esperado. É com base nisso que penso em migrar de vez do método manual para TDD de forma mais ampla.
Conclusão
Minha jornada com TDD não foi linear. Comecei cético, travei na granularidade, me senti mais lento e então vi um end-to-end passar de primeira. O que o TDD me deu não foi só código que funciona. Foi confiança para refatorar, segurança para mudar sem medo e código mais enxuto, porque a própria metodologia me impede de criar mais do que o necessário.
Se você quer começar, o caminho é simples:
- Escolha um projeto pequeno, de preferência pessoal.
- Escreva um único teste antes de qualquer código e veja ele falhar.
- Escreva o mínimo de código para passar, refatore e repita.
- Documente o processo e compare com o seu fluxo anterior.
Não espere que seja natural nem rápido no começo. Compare os números e veja por conta própria se faz diferença.
Referências
- Fowler, Martin. "Test Driven Development". martinfowler.com, dezembro de 2023.
- Beck, Kent. "Canon TDD". tidyfirst.substack.com, dezembro de 2023.
- Martin, Robert C. "The Cycles of TDD". blog.cleancoder.com, dezembro de 2014.
- Nagappan, Nachiappan; Maximilien, E. Michael; Bhat, Thirumalesh; Williams, Laurie. "Realizing quality improvement through test driven development: results and experiences of four industrial teams". Empirical Software Engineering, 13(3), 2008.
- Wikipedia. "Test-driven development".
- Wikipedia. "Mutation testing".
- Mierzwa, Matheus. "Meu Fluxo de Desenvolvimento com IA".