DryRUN: On the Role of Public Tests in LLM-Driven Code Generation

Título: DryRUN: Sobre o Papel dos Testes Públicos na Geração de Código Impulsionada por LLMs

1. Problema e Motivação

O artigo identifica uma dependência crítica e problemática nos frameworks atuais de geração de código por Inteligência Artificial (especialmente os baseados em agentes multiagentes, como CodeSIM). Esses sistemas dependem quase exclusivamente de casos de teste públicos (exemplos de entrada/saída fornecidos pelo humano na especificação do problema) para:

1. Ancorar o raciocínio lógico antes da geração do código.
2. Executar o código em um "sandbox" externo para obter feedback de depuração.
3. Simular mentalmente a execução apenas quando o código falha nesses testes públicos.

Os principais desafios identificados são:

• Falso Sentimento de Segurança (Overconfidence Gap): Os testes públicos em benchmarks padrão (como LiveCodeBench) são frequentemente triviais. Modelos tendem a "superajustar" (overfit) a esses exemplos simples, passando neles, mas falhando em testes privados ocultos que cobrem casos de borda complexos. Isso cria uma lacuna de confiança excessiva.
• Desconexão com o Mundo Real: Na engenharia de software real, exemplos de entrada/saída completos e ground-truth raramente estão disponíveis antes da implementação do código. A dependência de testes públicos limita a aplicabilidade desses métodos a benchmarks curados, não a cenários reais.
• Custo de Criação: Autorar manualmente testes públicos abrangentes é um processo laborioso e intensivo.

2. Metodologia: O Framework DryRUN

Os autores propõem o DryRUN (Debugging and Refinement Under Non-execution), um framework que opera sob restrições estritas de zero-exemplos (sem nenhum exemplo de entrada/saída fornecido pelo humano). O sistema substitui a execução externa e os testes públicos pela capacidade intrínseca do LLM de planejar, sintetizar inputs e simular execuções mentalmente.

O processo segue um ciclo iterativo descrito no Algoritmo 1:

1. Planejamento Inicial e Refinamento (Fase 1):

   • O LLM gera um plano de implementação baseado apenas na especificação do problema.
   • O plano passa por $N_{plan}$ iterações de refinamento autônomo (sem feedback externo), onde o modelo é instruído a adicionar detalhes, considerar casos de borda e corrigir falhas lógicas preliminares.

2. Síntese de Código e Simulação Mental (Fase 2):

   • O código é gerado a partir do plano refinado.
   • Em vez de executar o código, o LLM entra em um loop de $N_{sim}$ iterações:
     • Sintetização de Input: O modelo gera autonomamente uma entrada válida e não trivial baseada nas restrições do problema.
     • Rastreamento Mental (Mental Trace): O modelo simula a execução linha por linha do código com essa entrada gerada, rastreando o estado das variáveis para expor falhas lógicas ocultas.
     • Refinamento: O rastreamento é usado para atualizar o plano de implementação e regenerar o código, corrigindo os erros identificados.

3. Polimento Final (Fase 3):

   • Uma etapa final de polimento revisa o código e o plano para corrigir anomalias sintáticas ou lógicas que possam ter sido introduzidas durante o processo de regeneração, garantindo a alinhamento total.

Diferenças Chave em relação ao CodeSIM (SOTA):

• Entradas: DryRUN gera suas próprias entradas; CodeSIM usa os testes públicos falhos.
• Execução: DryRUN é totalmente livre de execução externa (sandbox); CodeSIM depende de execução real.
• Refinamento: DryRUN refina o plano proativamente antes do código; CodeSIM reage a falhas de execução.

3. Contribuições Principais

1. Questionamento da Necessidade de Testes Públicos: O trabalho demonstra empiricamente que os exemplos de entrada/saída fornecidos por humanos não são estritamente necessários para a geração de código correta, desafiando a premissa central dos benchmarks atuais.
2. Framework Zero-Exemplo: Introdução do DryRUN, que elimina a necessidade de oráculos externos, utilizando apenas a capacidade de simulação mental do LLM.
3. Mitigação do "Overconfidence Gap": Ao forçar o modelo a validar a lógica contra inputs sintetizados por ele mesmo (que são ajustados à sua capacidade de simulação), o framework reduz significativamente a confiança excessiva em soluções falhas que apenas passam em testes triviais.
4. Eficiência de Tokens: O DryRUN consome menos tokens de saída em comparação com frameworks que realizam múltiplas simulações de reparo baseadas em testes externos.

4. Resultados Experimentais

Os experimentos foram conduzidos no dataset LiveCodeBench v6 (problemas publicados após março de 2025, garantindo ausência de contaminação de dados), utilizando os modelos gpt-5-mini e gemini-3-flash.

• Desempenho (Pass@1):

  • O DryRUN alcançou desempenho comparável ao CodeSIM (o estado da arte dependente de testes públicos).
  • Com o gpt-5-mini, o DryRUN superou o CodeSIM em 3.3%.
  • Com o gemini-3-flash, o CodeSIM teve uma vantagem de 5.0%, mas as margens de erro se sobrepuseram, indicando paridade estatística.
  • Curiosamente, remover os exemplos públicos do baseline direto (Zero-shot) melhorou ligeiramente a precisão, sugerindo que os exemplos podem, às vezes, confundir o modelo.

• Eficiência Computacional:

  • O DryRUN consumiu apenas 70% dos tokens totais e 50% dos tokens de saída em comparação ao CodeSIM. Isso ocorre porque o DryRUN limita estritamente as iterações de simulação (2 rodadas), enquanto o CodeSIM pode executar até 25 simulações aninhadas em problemas difíceis.

• Análise do "Overconfidence Gap":

  • Gráficos (Figuras 3 e 4) mostram que o CodeSIM apresenta uma grande lacuna entre problemas que passam nos testes públicos e os que passam nos testes privados (falha em casos de borda).
  • O DryRUN manteve uma lacuna significativamente menor, indicando que as soluções geradas são mais robustas e menos propensas a superajuste em testes triviais.

• Limitação com SLMs: O framework não funcionou bem com Modelos de Linguagem Pequenos (SLMs, como qwen2.5-coder:7b), que falharam em seguir instruções complexas de múltiplos passos e introduziram erros de sintaxe frequentes.

5. Significado e Conclusão

O artigo conclui que a dependência atual de testes públicos em benchmarks de geração de código cria um viés que favorece modelos que "adivinham" a resposta para exemplos simples, em vez de compreender a lógica subjacente.

• Impacto na Engenharia de Software: O DryRUN alinha melhor a avaliação de LLMs com a realidade do desenvolvimento de software, onde oráculos completos raramente existem antes da codificação.
• Futuro dos Benchmarks: Os autores levantam a questão crítica de se os testes públicos devem ser removidos dos benchmarks de avaliação para evitar a criação de modelos superconfiantes e não robustos.
• Validação da Simulação Mental: O estudo prova que a capacidade de "pensar" e simular a execução de código internamente é suficiente para corrigir erros lógicos complexos, sem a necessidade de compilação ou execução externa, desde que o modelo tenha capacidade de raciocínio adequada (como LLMs grandes).

Em suma, o DryRUN demonstra que a geração de código autônoma e robusta é possível sem a "muleta" dos testes públicos, oferecendo uma alternativa mais eficiente e realista para o futuro da síntese de programas.