TDAD: Test-Driven Agentic Development - Reducing Code Regressions in AI Coding Agents via Graph-Based Impact Analysis

Resumo Técnico: TDAD

1. O Problema

Os agentes de codificação baseados em Grandes Modelos de Linguagem (LLMs) demonstraram capacidade impressionante para resolver problemas de software reais (como no benchmark SWE-bench). No entanto, há uma lacuna crítica na avaliação atual:

• Foco Excessivo na Taxa de Resolução: Os benchmarks atuais avaliam quase exclusivamente se o agente resolveu o problema específico (passou nos testes de falha).
• Negligência de Regressões: Pouco se estuda quantos testes que já passavam são quebrados pela correção do agente (regressões).
• Consequências: Regressões são uma das principais causas de rejeição de Pull Requests (PRs) gerados por IA. Sem consciência de dependências, os agentes tendem a quebrar testes indiretos ou não relacionados, especialmente em bases de código grandes.
• Limitação de Contexto: Os agentes têm janelas de contexto limitadas e não podem executar todos os testes (muito lento) ou apenas os testes próximos aos arquivos alterados (pode perder dependências indiretas).

2. Metodologia: TDAD (Test-Driven Agentic Development)

O TDAD é uma ferramenta de código aberto que realiza uma análise de impacto pré-alteração para agentes de IA. A abordagem central não é instruir o agente como fazer TDD (Desenvolvimento Orientado a Testes), mas sim informá-lo quais testes verificar.

Arquitetura e Fluxo de Trabalho:

1. Indexação (Fase 1): O sistema analisa um repositório Python e constrói um grafo de dependência código-teste.
   • Nós: Arquivos, Funções, Classes, Testes.
   • Arestas: Relações estruturais (CONTAINS), chamadas estáticas (CALLS), imports (IMPORTS), herança (INHERITS) e vinculação específica de testes (TESTS).
   • Técnica: Utiliza análise estática (AST) para mapear quais testes exercitam quais partes do código.
2. Análise de Impacto (Fase 2): Quando uma alteração é proposta, o sistema identifica os testes afetados com base em quatro estratégias ponderadas:
   • Direto: Testes que chamam o código alterado.
   • Transitivo: Testes que chamam funções que chamam o código alterado (até 3 saltos).
   • Cobertura: Dependência em nível de arquivo.
   • Imports: Arquivos que importam o arquivo alterado.
3. Integração com o Agente (Habilidade/Skill):
   • O resultado é exportado como um arquivo de texto estático leve (test_map.txt).
   • O agente recebe uma definição de habilidade curta (SKILL.md, ~20 linhas) que instrui: "Corrija o bug, use grep no test_map.txt para encontrar testes relacionados, execute-os e corrija falhas".
   • Vantagem: Não requer banco de dados em tempo de execução, servidores MCP ou chamadas de API complexas; o agente apenas lê o arquivo de texto.

3. Contribuições Principais

1. Ferramenta TDAD: Um utilitário de código aberto (pip install tdad) para análise de impacto de testes baseada em grafos.
2. Métrica de Regressão: Propõe elevar a "taxa de regressão" a uma métrica de primeira classe nos benchmarks de IA, ao lado da taxa de resolução.
3. Descoberta do "Paradoxo do Prompt TDD": Evidência empírica de que instruir agentes menores a seguir procedimentos longos de TDD (escrever teste -> implementar -> refatorar) sem contexto específico de quais testes verificar, aumenta as regressões.
4. Loop de Auto-aperfeiçoamento: Um mecanismo onde o próprio agente refina iterativamente a configuração do TDAD (ex: simplificar prompts, melhorar heurísticas de mapeamento), melhorando o desempenho da ferramenta.
5. Dados Públicos: Todos os códigos, dados e logs de 28 experimentos estão disponíveis sob licença MIT.

4. Resultados Experimentais

Os experimentos foram realizados no subset SWE-bench Verified (500 issues validadas por humanos) em duas fases:

Fase 1: Redução de Regressões (100 instâncias, Modelo Qwen3-Coder 30B)

• Baseline (Vanilla): 6.08% de taxa de regressão (562 falhas de testes P2P).
• Apenas Prompt TDD (sem contexto de grafo): Aumentou as regressões para 9.94% (pior que o baseline). Isso confirma o paradoxo: instruções procedurais longas consomem contexto e distraem o modelo.
• TDAD (GraphRAG + TDD): Reduziu as regressões para 1.82% (155 falhas).
  • Redução de 70% na taxa de regressão em comparação ao baseline.
  • Redução de 81% em comparação ao prompt TDD puro.
  • A taxa de resolução caiu ligeiramente (31% para 29%), pois o agente tornou-se mais conservador, abstendo-se de gerar patches quando o mapa de testes indicava alto risco de regressão.

Fase 2: TDAD como Habilidade de Agente (25 instâncias, Modelo Qwen3.5-35B-A3B + OpenCode)

• Ao usar o TDAD como uma habilidade reutilizável em um framework diferente:
  • A taxa de resolução aumentou de 24% para 32%.
  • A taxa de geração de patches aumentou de 40% para 68%.
  • Taxa de regressão mantida em 0% (devido ao conjunto menor de instâncias).
• Conclusão: Fornecer contexto estrutural (o grafo) supera a prescrição de fluxos de trabalho procedurais.

Loop de Auto-aperfeiçoamento:

• Em um subconjunto de 10 instâncias, o agente refinou o TDAD autonomamente.
• A mudança mais impactante foi simplificar o SKILL.md de 107 linhas para 20 linhas.
• Resultado: A resolução saltou de 12% para 60% com 0% de regressão.

5. Significado e Implicações

• Contexto > Procedimento: Para modelos menores ou com janelas de contexto limitadas, fornecer informações contextuais precisas ("quais testes verificar") é muito mais eficaz do que instruir sobre o processo ("como escrever testes").
• Mudança de Paradigma na Avaliação: A indústria de benchmarks de IA para codificação deve começar a penalizar regressões. Um patch que resolve um bug mas quebra 100 testes existentes tem valor negativo.
• Viabilidade Técnica: É possível reduzir drasticamente as regressões em agentes de IA sem infraestrutura pesada em tempo de execução, utilizando apenas análise estática e arquivos de texto simples.
• Escalabilidade: A abordagem funciona em hardware de consumo (GPUs locais) e com modelos de tamanho médio (30B-35B), tornando-a acessível para adoção prática.

Em suma, o TDAD demonstra que a consciência de dependência via análise de grafos é a chave para tornar os agentes de codificação mais seguros e confiáveis, transformando a abordagem de "tentar e corrigir" para "verificar antes de comprometer".