💻 computer science

HAFix: History-Augmented Large Language Models for Bug Fixing

O artigo apresenta o HAFix, uma abordagem inovadora que aprimora a capacidade de modelos de linguagem grandes (LLMs) na correção de bugs ao aproveitar dados históricos de repositórios de software e diferentes estilos de prompts, demonstrando ganhos significativos de desempenho em comparação com bases não históricas.

Autores originais: Yu Shi, Abdul Ali Bangash, Emad Fallahzadeh, Bram Adams, Ahmed E. Hassan

Publicado 2026-02-20

📖 4 min de leitura☕ Leitura rápida

CC BY 4.0

Autores originais: Yu Shi, Abdul Ali Bangash, Emad Fallahzadeh, Bram Adams, Ahmed E. Hassan

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

Imagine que você é um detetive tentando resolver um crime (um "bug" no código) que aconteceu em uma fábrica de software.

Até hoje, a maioria dos detetives (os modelos de Inteligência Artificial, ou LLMs) olhava apenas para a cena do crime no momento atual. Eles viam a sala bagunçada, o objeto quebrado e tentavam adivinhar o que aconteceu. Eles não olhavam para o diário de bordo, as câmeras de segurança antigas ou o que os funcionários fizeram nos dias anteriores.

O artigo "HAFix" propõe uma mudança de estratégia: não olhe apenas para o "agora", olhe para a "história".

Aqui está uma explicação simples do que os pesquisadores descobriram, usando analogias do dia a dia:

1. O Problema: O Detetive com Amnésia

Os modelos de IA atuais são muito inteligentes, mas quando tentam consertar um código, eles agem como se tivessem amnésia. Eles veem o código quebrado, mas não sabem quem o escreveu, por que foi alterado antes ou quais outras peças do sistema mudaram junto com ele. É como tentar consertar um carro sem saber quem trocou o pneu na semana passada ou por que o motor foi modificado.

2. A Solução: O HAFix (O Detetive com Memória)

Os autores criaram o HAFix (History-Augmented LLMs). A ideia é simples: antes de pedir à IA para consertar o bug, eles lhe entregam um "caderno de anotações históricas".

Esse caderno contém sete tipos de pistas baseadas no histórico do projeto (como quem mexeu no arquivo, quais outras funções foram alteradas ao mesmo tempo, etc.).

Analogia: Em vez de apenas mostrar a foto do carro batido, você mostra ao mecânico: "Olha, na terça-feira o João trocou o freio, e na quinta a Maria pintou a porta. O carro bateu na sexta. O que você acha que aconteceu?"

3. A Descoberta Principal: A História Funciona!

O estudo testou essa ideia em milhares de bugs reais (de programas em Python e Java).

O Resultado: Quando a IA tinha acesso a essas pistas históricas, ela consertou muito mais bugs do que quando trabalhava apenas com o código atual.
A Mágica da Agregação (HAFix-Agg): Os pesquisadores perceberam que nenhuma única pista era perfeita. Às vezes, saber "quem mexeu no arquivo" ajudava; outras vezes, saber "o que mudou no código" era melhor. Então, eles criaram uma versão que junta todas as pistas.
O Ganho: Essa abordagem combinada aumentou a taxa de sucesso em cerca de 45% a 50% em comparação com os métodos antigos. É como ter um time de detetives, onde cada um traz uma peça diferente do quebra-cabeça, e juntos eles resolvem o caso que um sozinho não conseguiria.

4. O Estilo da Pergunta (Prompting)

Os pesquisadores também testaram como eles faziam a pergunta para a IA.

A Analogia: É a diferença entre dizer: "Aqui está o código, arrume isso" (Estilo Instrução) vs. "Aqui está o código, e eu pintei de vermelho a parte quebrada" (Estilo Rótulo) vs. "Aqui está o código, mas apaguei a parte quebrada, preencha o buraco" (Estilo Máscara).
O Veredito: O estilo mais direto e claro (Instrução), onde você explica o problema e mostra o contexto, funcionou melhor na maioria das vezes. A IA prefere clareza do que jogos de esconderijo.

5. O Custo: Vale a Pena?

Claro, ler um caderno de história inteiro demora mais e custa mais caro (em tempo de processamento e "tokens" de IA) do que olhar apenas a foto atual.

A Estratégia Inteligente (Early Stop): Os autores descobriram que você não precisa ler toda a história para todos os casos. Eles criaram uma estratégia de "parar cedo".
Como funciona: A IA tenta consertar o bug usando a primeira pista histórica. Se funcionar, ela para e não gasta tempo com as outras 6 pistas. Se falhar, ela tenta a próxima.
O Benefício: Isso reduziu o tempo e o custo em cerca de 70%, mantendo quase o mesmo nível de sucesso. É como um detetive que, ao encontrar a primeira pista sólida, não perde tempo revirando todo o arquivo, economizando recursos.

Resumo Final

O HAFix nos ensina que, para consertar coisas complexas (como software), o contexto histórico é fundamental.

Não ignore o passado: Saber a evolução do código ajuda a IA a entender a causa raiz do erro.
Junte as pistas: Usar várias fontes de informação histórica é melhor do que usar apenas uma.
Seja inteligente com o custo: Não gaste energia lendo tudo se você já encontrou a solução; pare assim que o bug estiver consertado.

Em suma, o estudo mostra que dar "memória" para a Inteligência Artificial é uma das chaves para torná-la uma ferramenta muito mais poderosa e confiável na engenharia de software.

Resumo Técnico: HAFix

1. Problema e Motivação

Os Grandes Modelos de Linguagem (LLMs) têm demonstrado capacidades notáveis em tarefas de Engenharia de Software, como geração de código e correção de bugs. No entanto, a maioria das abordagens atuais baseia-se apenas no contexto do "snapshot" atual do projeto (código circundante, função atual), ignorando o potencial rico dos dados históricos armazenados nos repositórios de software (como commits de culpa, evolução do código e motivação por trás de correções anteriores).

Além disso, existem lacunas na compreensão de:

Como diferentes estilos de prompt (instrução, rótulo, preenchimento) afetam o desempenho de LLMs quando combinados com contexto histórico.
O custo computacional e de tempo de inferência ao incorporar esses dados históricos, e como equilibrar desempenho versus eficiência.

2. Metodologia: A Abordagem HAFix

Os autores propõem o HAFix (History-Augmented LLMs on Bug Fixing), uma abordagem que enriquece os prompts dos LLMs com heurísticas históricas extraídas de dados de "blame commit" (o commit que modificou a linha de código com o bug pela última vez).

Coleta de Dados e Heurísticas:
O processo de coleta de dados segue uma linha do tempo reversa a partir do commit de correção (V4) até o commit anterior ao que introduziu o bug (V1). A partir disso, são extraídas sete heurísticas históricas divididas em três categorias:

Baseadas em Nomes:
- CFN-modified: Nomes de funções modificadas no arquivo com o bug.
- CFN-all: Nomes de funções modificadas em todos os arquivos alterados.
- FN-modified: Nomes de todas as funções no arquivo com o bug (modificadas ou não).
- FN-all: Nomes de todas as funções em todos os arquivos modificados.
- FLN-all: Nomes dos arquivos modificados.
Evolução de Código:
- FN-pair: Pares de código de função (antes e depois do commit de culpa).
Nível de Patch:
- FL-diff: O diff completo do patch do commit.

Aggregação (HAFix-Agg):
Para evitar prompts excessivamente grandes, os autores propõem o HAFix-Agg, que executa cada heurística individualmente e agrega os resultados, combinando as forças complementares de cada abordagem histórica.

Configuração Experimental:

Datasets: 51 bugs de linha única em Python (BugsInPy) e 116 bugs em Java (Defects4J).
Modelos: CodeLlama-Instruct-7B, DeepSeek-Coder-Instruct-6.7B e DeepSeek-Coder-V2-Lite-Instruct-16B.
Estilos de Prompt:
- Instruction: Código completo com a linha defeituosa destacada no texto da instrução.
- InstructionLabel: Linha defeituosa marcada com tag <BUGGY LINE>.
- InstructionMask: Linha defeituosa mascarada com <FILL ME>.
Métrica de Avaliação: pass@k (probabilidade de gerar pelo menos uma correção correta em $k$ tentativas).

3. Principais Contribuições

Integração de Contexto Histórico: Demonstra que heurísticas derivadas de commits de culpa podem melhorar significativamente a capacidade de correção de bugs de LLMs.
Avaliação de Estilos de Prompt: Identifica o estilo Instruction como o mais eficaz para a maioria das configurações, superando estilos com máscaras ou rótulos explícitos no contexto histórico.
Análise de Custo-Desempenho: Fornece uma análise pragmática dos trade-offs entre tempo de inferência, uso de tokens e taxa de sucesso, introduzindo estratégias de parada antecipada (Early Stopping).

4. Resultados Chave

RQ1: Melhoria no Desempenho de Correção

Heurísticas Individuais: Várias heurísticas (especialmente FN-modified e FN-all no dataset Defects4J) alcançaram melhorias estatisticamente significativas com tamanhos de efeito grandes em comparação à linha de base (inspirada no GitHub Copilot).
Complementaridade: Cada heurística corrigiu um subconjunto único de bugs que a linha de base falhou em resolver (média de +16,30% em bugs únicos no BugsInPy e +19,24% no Defects4J).
HAFix-Agg: A abordagem agregada obteve melhorias substanciais, aumentando as taxas de correção de bugs em 45,05% (BugsInPy) e 49,92% (Defects4J) em relação à linha de base.
Comparação com SOTA: O HAFix-Agg superou ferramentas de ponta como ChatRepair e ITER em bugs de linha única, mesmo utilizando modelos de código aberto menores.

RQ2: Impacto dos Estilos de Prompt

O estilo Instruction foi consistentemente superior na maioria das configurações de modelo e dataset, permitindo que o modelo utilizasse melhor as heurísticas históricas.
O estilo InstructionMask mostrou-se competitivo apenas em configurações específicas (ex: DeepSeek-Coder-V2-Lite no BugsInPy).

RQ3: Análise de Custo e Eficiência

Parada Antecipada (Early Stopping): Executar heurísticas sequencialmente e parar assim que uma correção válida é encontrada reduz o tempo de inferência em 69% e o uso de tokens em 73% em comparação com a execução exaustiva (Exhaustive), mantendo um desempenho competitivo.
Heurísticas Custosas: As heurísticas FL-diff e FN-all tendem a ser as mais custosas em termos de tempo e tokens, com ganhos de desempenho variáveis.
Otimização: A estratégia ES-UniSorted (ordenar heurísticas pela quantidade de bugs únicos corrigidos) ofereceu benefícios adicionais na redução de tokens para tentativas falhas em certas configurações.

5. Significância e Conclusão

O estudo valida a hipótese de que o contexto histórico de repositórios de software é um recurso subutilizado e valioso para LLMs na correção de bugs. O HAFix demonstra que:

A combinação de múltiplas perspectivas históricas supera abordagens baseadas apenas no estado atual do código.
É possível alcançar ganhos massivos de desempenho sem comprometer a viabilidade econômica, através de estratégias de execução inteligente (como parada antecipada).
O design do prompt é crítico; instruções claras e explícitas funcionam melhor do que técnicas de preenchimento (infilling) para este tipo de tarefa.

Este trabalho oferece diretrizes acionáveis para a implementação prática de sistemas de correção de bugs automatizados, equilibrando a precisão da correção com os custos computacionais, e abre caminho para futuras pesquisas em bugs mais complexos (multilinha) e outras tarefas de engenharia de software.