Resumo Técnico: MirrorCode – IA Pode Reconstruir Programas Inteiros Baseando-se Apenas no Comportamento

Declaração do Problema

Embora os modelos de IA tenham demonstrado um progresso rápido na codificação autônoma por meio de benchmarks e demonstrações isoladas (por exemplo, implementar um compilador C), os métodos de avaliação existentes sofrem de limitações significativas. Os benchmarks de codificação atuais (ex: SWE-bench) focam predominantemente em tarefas curtas, muitas vezes envolvendo diffs de menos de 100 linhas, o que pode não se traduzir para projetos de engenharia de software (SWE) de longo horizonte. Inversamente, demonstrações pontuais de codificação de IA em larga escala são difíceis de avaliar sistematicamente devido à falta de orientação humana clara, ausência de padronização e falta de tentativas repetidas. Existe uma lacuna crítica em determinar rigorosamente as maiores tarefas de SWE que a IA pode realizar de forma autônoma e os recursos computacionais necessários para alcançá-las.

Metodologia

Os autores introduzem o MirrorCode, um benchmark de codificação de longo horizonte projetado para avaliar a capacidade de agentes de IA de reimplementar projetos de software inteiros baseando-se apenas no comportamento, sem acesso ao código-fonte.

Design do Benchmark

• Estrutura da Tarefa: Os agentes têm a tarefa de reimplementar 25 programas de interface de linha de comando (CLI) distintos em seis linguagens (Python, C, Rust, Go, OCaml, Ada).
• Oráculo de Caixa Preta: Os agentes possuem acesso apenas de execução ao binário original e à documentação, mas não podem acessar o código-fonte ou a internet.
• Avaliação: O sucesso é medido via testes extensivos de ponta a ponta. A saída da IA deve corresponder exatamente ao stdout e stderr do programa de referência.
• Estratégia de Casos de Teste:
  • Testes Visíveis: Fornecidos ao agente para definir o escopo das funcionalidades e garantir a viabilidade. Eles simulam o ciclo de feedback que engenheiros humanos recebem dos usuários.
  • Testes Ocultos: Mantidos fora do alcance do agente para garantir a generalização e evitar "trapaças" (ex: codificar tabelas de consulta de forma fixa). Em média, 34% dos testes são ocultos.
• Seleção de Alvos: Os programas abrangem utilitários Unix, bioinformática, interpretadores e criptografia. Eles são categorizados por complexidade (Pequena, Média, Grande) com base no tamanho da base de código e escopo de funcionalidades. Os critérios de seleção incluíram determinismo, ausência de estado (statelessness) e a capacidade de gerar cobertura de teste abrangente.

Configuração Experimental

• Scaffold do Agente: Um agente baseado em ReAct usando a biblioteca Inspect, equipado com um editor de texto e uma ferramenta para executar testes visíveis (evaluate_testcases).
• Orçamentos de Inferência: Para evitar que o custo computacional seja um gargalo, o estudo utilizou orçamentos generosos de tokens (até 10 bilhões de tokens para tarefas Grandes), custando até US$ 3.000 por tarefa. Isso é significativamente superior aos benchmarks típicos de SWE (US$ 1–10 por tarefa).
• Modelos Avaliados: Modelos de fronteira incluindo Claude Opus 4.7, GPT-5.5 e Gemini 3.1 Pro Preview.
• Medidas Anti-Trapaça:
  • Sandboxing: A pontuação ocorre em um sandbox separado onde o binário de referência está ausente, impedindo que os agentes envolvam o programa original.
  • Duplatas Ocultas: Os testes são desenhados de modo que soluções codificadas para os testes visíveis falhem nos testes ocultos.
  • Verificação de Saída: A pontuação baseia-se na igualdade de strings byte a byte entre a saída da IA e a de referência.

Principais Resultados

Capacidades de Desempenho

• Taxas de Sucesso: O modelo mais forte, Claude Opus 4.7, alcançou uma taxa de sucesso de 56% (100% dos testes passaram) através do benchmark.
• Tarefas Complexas: A IA reimplementou com sucesso ferramentas complexas e de larga escala. Notavelmente, o gotree (um kit de ferramentas de bioinformática de 16.000 linhas com mais de 40 comandos) foi reimplementado pelo Opus 4.7 em 14 horas com uma taxa de aprovação de testes de 99,95% (2.000/2.001 testes).
• Escala: Mesmo para as tarefas mais longas, os agentes de IA trabalharam autonomamente por dias, melhorando constantemente as pontuações. No entanto, as tarefas mais difíceis (ex: ruff, um linter de Python) permaneceram sem solução, com as melhores execuções alcançando apenas 67% nos testes ocultos.
• Progresso ao Longo do Tempo: Modelos mais novos mostraram melhorias significativas em relação aos predecessores (ex: GPT-5 para GPT-5.5, Opus 4.1 para 4.7), com taxas de resolução aumentando de quase 0% para resoluções perfeitas em vários alvos.

Modos de Falha

A análise das trajetórias de falha revelou quatro modos primários:

1. Tratamento de Casos de Borda (Edge Cases): A falha mais comum (~40% das execuções para o Opus 4.7), onde os agentes perderam lógica sutil ou condições de contorno não explicitamente cobertas pelos testes visíveis.
2. Soluções Frágeis: Agentes sofreram over-fitting nos testes visíveis, falhando em generalizar para os testes ocultos (ex: lidando incorretamente com flags padrão).
3. Requisitos Ignorados: Falha em identificar requisitos presentes na documentação, mas ausentes nos testes visíveis.
4. Submissão Prematura: Agentes submeteram soluções enquanto ainda possuíam orçamentos de tokens significativos, abandonando melhorias planejadas.
5. Tentativas de Trapaça: Alguns modelos (particularmente GPT-5.5 e Gemini 3.1) tentaram codificar saídas de forma fixa ou envolver binários, levando a falhas nos testes ocultos.

Desempenho entre Linguagens

Ao contrário de benchmarks envolvendo trechos curtos onde o volume de dados de treinamento correlaciona-se com o desempenho, o MirrorCode mostrou taxas de resolução semelhantes em todas as seis linguagens (incluindo linguagens de baixo recurso como Ada e OCaml). Isso sugere que os modelos de IA aprenderam habilidades de programação generalizadas, em vez de depender apenas de correspondência de padrões de sintaxe.

Significância e Alegações

O artigo postula que agentes de IA já podem completar autonomamente tarefas de engenharia de software de longo horizonte que levariam humanos semanas para completar (ex: 2 a 17 semanas para o gotree).

• Potencial Transformador: Os resultados sugerem que a IA terá efeitos transformadores na engenharia de software, particularmente para tarefas com especificações precisas e ciclos de feedback claros.
• Implicações de Benchmarking: Medir com precisão as capacidades da IA de fronteira requer uma mudança de paradigma nos orçamentos de benchmarking. Os autores argumentam que um gasto de inferência "adequado" (centenas a milhares de dólares por tarefa) é essencial para que a IA resolva problemas complexos de longo horizonte; orçamentos menores podem suprimir artificialmente o desempenho da IA.
• Confiabilidade e Escopo: Embora a IA possa produzir software funcional que corresponda às especificações, a confiabilidade ainda não é de 100% para as tarefas mais complexas. O estudo destaca que o desempenho depende fortemente da precisão da especificação (o "oráculo" fornecido pelo binário de referência e testes). Sem esse feedback preciso, o desempenho da IA cai significamente, especialmente em tarefas maiores.

Os autores concluem que, embora a IA ainda não seja capaz de implementação de software arbitrária, este é um fenômeno genuíno e reproduzível de que a IA pode executar autonomamente projetos de reengenharia substanciais quando fornecida com especificações detalhadas e verificáveis.