🤖 machine learning

Learning from 53.6K Real-World Developer Edits of AI-Generated Code

Este artigo apresenta o DECODE, um conjunto de dados de 53.600 edições de código gerado por IA em ambientes de desenvolvimento (IDE) do mundo real, realizadas por mais de 1.000 desenvolvedores, o qual revela que a maioria das modificações ocorre dentro de 15 minutos após a aceitação e demonstra que o ajuste fino de modelos menores com esses dados supera significativamente os LLMs de fronteira na previsão de edições de código.

Autores originais: Jenny T. Liang, Mihika Bairathi, Wayne Chi, Ameet Talwalkar, Nishant Subramani, Valerie Chen

Publicado 2026-07-29

📖 6 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Jenny T. Liang, Mihika Bairathi, Wayne Chi, Ameet Talwalkar, Nishant Subramani, Valerie Chen

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ê está ensinando um robô a cozinhar. Você mostra a ele um livro de receitas, e ele tenta fazer um prato. Às vezes, o robô acerta perfeitamente. Mas, frequentemente, ele adiciona sal demais, esquece o alho ou usa uma colher em vez de um batedor de arame. No mundo da ciência da computação, esse robô é um "assistente de programação de IA", e os pratos são linhas de código. Por muito tempo, os cientistas tentaram ensinar esses robôs mostrando-lhes receitas prontas (chamadas de "Git commits") — os pratos finais, perfeitos, que foram para os livros de receitas. Mas isso é como tentar aprender a cozinhar olhando apenas para a comida no prato, ignorando a cozinha bagunçada, a torrada queimada e as correções frenéticas do chef.

A verdadeira magia (e a verdadeira bagunça) acontece no meio. Quando um chef humano prova uma sopa e diz: "Não, precisa de mais pimenta", ou "Na verdade, jogue isso fora e comece de novo", isso é uma "edição de código". Até agora, não tínhamos uma boa maneira de observar o chef fazendo isso. Só víamos o resultado final. Este artigo mergulha nessa cozinha bagunçada e bela. Ele pergunta: Como os humanos realmente consertam os erros da IA? Eles fazem pequenos ajustes ou jogam tudo fora e começam do zero? E podemos ensinar o robô a prever esses ajustes antes mesmo que eles aconteçam?

O Grande Detetive de Código: DECODE

Os pesquisadores por trás deste estudo perceberam que, para tornar a IA melhor em escrever código, eles precisavam parar de olhar para o produto acabado e começar a observar o processo. Eles criaram um novo conjunto de dados massivo chamado DECODE (Developer Edits of Code Dataset). Pense no DECODE como um sistema de câmeras de segurança gigantesco e de alta definição instalado nas IDEs (os espaços de trabalho digitais) de mais de 1.000 desenvolvedores reais. Em vez de apenas salvar o código final, este sistema registrou cada toque, exclusão e reescrita que um desenvolvedor fez após a IA sugerir um trecho de código.

Eles coletaram 53.600 dessas sessões de edição do mundo real, principalmente em Python, TypeScript e JavaScript. É como ter uma biblioteca de 53.600 histórias sobre como humanos e robôs discutem, fazem concessões e colaboram para construir softwares.

O Que Eles Descobriram: A Regra dos 15 Minutos e a "Lata de Lixo"

Quando a equipe analisou os dados, encontrou alguns padrões surpreendentes sobre como os humanos tratam as sugestões da IA.

Primeiro, eles descobriram uma regra estrita de 15 minutos. A maior parte das edições acontece muito rapidamente. Se um desenvolvedor for alterar o código da IA, ele geralmente o faz dentro dos primeiros 15 minutos após aceitar a sugestão. Depois disso, o código geralmente é deixado de lado.

Segundo, eles descobriram que os humanos são surpreendentemente rigorosos. Em cerca de 31% dos casos, o desenvolvedor não apenas ajustou o código; ele deletou toda a sugestão da IA e começou do zero. É como se a IA lhe entregasse um sanduíche e você o jogasse imediatamente no lixo porque o pão estava ligeiramente errado. Os dados sugerem que, se uma sugestão de IA não se encaixa perfeitamente na intenção do desenvolvedor de imediato, ela muitas vezes está destinada ao abandono.

No entanto, quando os humanos mantêm o código, eles não mudam muito. Os dados mostram que, para o código que sobrevive, os desenvolvedores geralmente mantêm cerca de 63% da sugestão original da IA. Eles tendem a adicionar muito pouco de seu próprio código novo (apenas cerca de 20% do código final é conteúdo novo adicionado pelo humano). Isso significa que os desenvolvedores dependem fortemente da IA, mas são muito exigentes quanto à qualidade inicial.

Os pesquisadores também notaram uma ordem específica de como as pessoas corrigem as coisas. É como um checklist:

O teste "Isso é sequer utilizável?": Primeiro, eles decidem se querem manter o código ou não. Se não, eles o deletam.
A fase "Corrigir os bugs": Em seguida, eles corrigem erros de sintaxe ou problemas de legibilidade.
A fase "Tornar meu": Depois, eles renomeiam variáveis ou alteram números para se adequarem às suas necessidades específicas.
A fase "Mudar o plano": Finalmente, se ainda estiverem trabalhando nele, podem mudar o que o código realmente faz.

Ensinando o Robô a Ler Mentes

A segunda grande parte do artigo foi um teste: Podemos ensinar um modelo de IA menor e de código aberto a prever essas edições melhor do que os modelos gigantes e "de fronteira"?

Geralmente, os modelos de IA maiores e mais caros são considerados os melhores em tudo. Mas aqui, os pesquisadores pegaram um modelo menor (um com 3 bilhões de parâmetros, minúsculo comparado aos gigantes) e o treinaram especificamente no conjunto de dados DECODE. Eles o ensinaram a olhar para uma sugestão de IA e adivinhar: "O humano vai deletar isso? Ele vai ajustar? Ou ele vai deixar como está?"

O resultado foi um choque. O modelo pequeno, após aprender com os dados de edição do mundo real, tornou-se significativamente melhor em prever edições do que os modelos massivos e de última geração que nunca tinham visto esses dados específicos.

Para adivinhar como o código final ficaria, o modelo pequeno melhorou sua precisão em 0,17 (um salto enorme neste campo).
Para adivinhar se o código seria alterado, ele também melhorou em 0,17.

Isso sugere que ter a "experiência" certa (dados de edição do mundo real) é mais importante do que apenas ter um céreão maior. É como um jovem chef que assistiu a milhares de programas de culinária (os dados) e pode saber como consertar um prato melhor do que um chef famoso que só cozinhou refeições perfeitas em um laboratório.

A Conclusão: É Sobre o Humano, Não Apenas o Código

O artigo conclui que precisamos parar de tratar a geração de código por IA como um problema matemático onde o único objetivo é a "corretude". O verdadeiro objetivo é o "alinhamento". O código precisa se ajustar à intenção do humano, ou o humano simplesmente o jogará fora.

Os autores sugerem que os futuros assistentes de IA não devem apenas tentar escrever o código perfeito na primeira tentativa. Em vez disso, eles devem ser treinados para entender o processo de edição. Eles precisam aprender que os humanos frequentemente deletam coisas rapidamente, que corrigem erros antes de mudar funcionalidades e que são mais propensos a manter códigos que sejam fáceis de ajustar.

Ao usar conjuntos de dados como o DECODE, podemos construir IAs que não apenas escrevem código, mas escrevem códigos que os humanos realmente querem manter. É uma mudança de perguntar "Este código está correto?" para perguntar "Este código é algo que um humano pode facilmente tornar seu?". E os dados sugerem que, se ensinarmos nossa IA a entender a bagunçada janela de edição de 15 minutos, poderemos finalmente ter um robô que cozinha uma refeição que nos dê prazer em comer.

Resumo Técnico: Aprendendo com 53,6K Edições de Código Gerado por IA no Mundo Real

Declaração do Problema

Apesar da ampla adoção de assistentes de programação por IA, o código gerado é frequentemente imperfeito, contendo bugs ou desalinhando-se com estilos de codificação específicos. Consequentemente, os desenvolvedores devem modificar manualmente o código gerado pela IA, seja por meio de edição direta ou por meio de novos comandos (re-prompting) ao modelo. Os Grandes Modelos de Linguagem (LLMs) atuais são treinados primariamente em dados públicos de Git (ex: commits e pull requests) para aprender a edição de código. No entanto, os dados do Git representam apenas o estado final e bem-sucedido do código, carecendo dos passos intermediários, da ordenação temporal e do contexto do processo de edição real. Essa lacuna limita a capacidade dos LLMs de prever ou modelar como os desenvolvedores interagem com e modificam as conclusões da IA em tempo real. Além disso, os conjuntos de dados existentes frequentemente dependem de dados sintéticos, ambientes de laboratório ou edições instruídas, falhando em capturar as nuances das edições manuais de conteúdo gerado por IA no mundo real.

Metodologia

1. Construção do Conjunto de Dados: DECODE

Para enfrentar a falta de dados de edição realistas, os autores introduzem o DECODE (Developer Edits of Code Dataset), uma coleção de 53,6K edições de código de IA feitas em IDEs no mundo real.

Fonte: Os dados foram coletados de uma extensão do Visual Studio Code (VS Code) utilizada por mais de 1.000 desenvolvedores. A extensão captura conclusões de IA e snapshots do arquivo de trabalho toda vez que um desenvolvedor faz uma pausa de um segundo.
Escopo: O conjunto de dados abrange Python, TypeScript e JavaScript, abrangendo 20 LLMs diferentes e diversos contextos de desenvolvimento (ex: desenvolvimento web, análise de dados, aprendizado de máquina).
Pipeline de Extração:
1. Identificação: Correspondência de arquivos de código contendo conclusões de IA aceitas ( $y_0$ ) com snapshots subsequentes ( $y_t$ ).
2. Extração: Uso de git diff --histogram para isolar linhas específicas adicionadas, removidas ou modificadas em relação à conclusão original. Isso reduziu os dados brutos de 6,5 milhões de linhas para 772,2 mil linhas diretamente relevantes para as edições.
3. Limpeza: Validação de trajetórias usando CodeBERTScore (limiar de 0,68) para garantir a relevância e remoção de dados malformados.
4. Privacidade: Aplicação de pipelines de redação de PII (Starcoder/Stack e OpenAI Privacy Filter) para remover informações de identificação pessoal.
Estatísticas: O conjunto de dados final compreende 5.831 trajetórias de edição de 1.141 desenvolvedores, com uma duração mediana de trajetória de ~50 minutos e uma mediana de 329 edições de Levenshtein por trajetória.

2. Análise do Comportamento do Desenvolvedor

Os autores utilizaram o DECODE para analisar quando, por que e como os desenvolvedores editam o código da IA usando métricas como a proporção de código restante da IA, código adicionado pelo desenvolvedor e volume total de edição.

Padrões Temporais: 50% das edições ocorrem dentro dos primeiros 50 minutos após a aceitação, com uma queda acentuada após 15 minutos.
Tipos de Edição: As edições foram classificadas em quatro categorias: Customização de código (10%), Melhoria de qualidade (14%), Mudança de funcionalidade (56%) e Remoção de conclusões (9%).
Resultados: 31% das trajetórias resultam na remoção completa da conclusão da IA. A distribuição do código restante é bimodal: desenvolvedores ou mantêm o código com poucas modificações ou o descartam inteiramente.

3. Benchmarking de LLMs

O estudo avaliou a capacidade dos LLMs de prever edições de código em duas tarefas:

Classificação: Prever se uma conclusão de IA será deletada, não modificada ou modificada.
Geração: Prever o estado final do código ( $y_t$ ) dada a conclusão inicial da IA ( $y_0$ ).
Modelos Testados: Modelos de fronteira (ex: GPT-5.2, Claude Sonnet 4.6) e modelos de código aberto (ex: Qwen2.5-Coder, Llama3.2) foram testados em configurações de poucos disparos (few-shot) e após ajuste fino (fine-tuning) no DECODE usando LoRA.

Principais Resultados

1. Insights sobre o Comportamento do Desenvolvedor

Abandono Rápido: Desenvolvedores frequentemente abandonam conclusões de IA rapidamente se elas não se alinham com sua intenção. 23% das trajetórias envolvem remoção imediata, frequentemente seguida pela escrita de uma implementação própria pelo desenvolvedor.
Baixa Taxa de Adição: Desenvolvedores raramente adicionam código novo significativo às conclusões de IA; 20% do código final é adicionado pelo desenvolvedor, e 36% das trajetórias contêm menos de 5% de novo código do desenvolvedor.
Edição Sequencial: Um padrão comum emerge onde os desenvolvedores primeiro decidem se manterão o código (remoção), depois corrigem erros (qualidade), adaptam às necessidades (customização) e, finalmente, modificam a funcionalidade.

2. Melhorias de Desempenho via Fine-Tuning

Superioridade de Pequenos Modelos com Fine-Tuning: O ajuste fino de modelos de código aberto (3B e 7B parâmetros) no DECODE superou significativamente os modelos de fronteira tanto nas tarefas de classificação quanto de geração.
- Classificação: Modelos de 3B com fine-tuning alcançaram um F1 score de 0,42–0,45, superando modelos de fronteira como Claude Sonnet 4.6 (0,37) e GPT-5.2 (0,32).
- Geração: Modelos com fine-tuning melhoraram a similaridade de Levenshtein em +0,15 a +0,22 em relação às suas versões base e superaram significativamente os modelos de fronteira (ex: +0,17 de melhoria sobre os baselines de fronteira).
Quantidade de Dados: O desempenho melhorou conforme os modelos eram expostos a mais etapas de edição durante o treinamento (até 4 etapas), sugerindo que capturar a natureza sequencial das edições é crucial.
Sem Degradação: O fine-tuning no DECODE não degradou as capacidades de geração de código em benchmarks padrão (HumanEval, MBPP); em alguns casos (Qwen2.5-Coder-3B), o desempenho melhorou ligeiramente.

Significância e Alegações

O artigo argumenta que abordagens de aprendizado de máquina centradas no desenvolvedor são necessárias para a próxima geração de assistentes de programação por IA. As principais conclusões são:

Alinhamento sobre Correção: Benchmarks padrão focam na correção do código (pass@k), mas a utilidade no mundo real depende de quão bem o código se alinha com a intenção e o contexto do desenvolvedor. Desenvolvedores frequentemente descartam código "correto" se ele não for facilmente adaptável.
Editabilidade como Métrica: A capacidade de o código gerado por IA ser facilmente editado (editabilidade) é um fator crítico, porém submedido. Modelos futuros devem ser capazes de detectar gerações que têm alta probabilidade de serem descartadas.
Modelagem Temporal: LLMs devem capturar a natureza sequencial e temporal das edições dos desenvolvedores (ex: remoções acontecem cedo, mudanças de funcionalidade acontecem mais tarde). Treinar em commits brutos do Git falha em capturar esse processo dinâmico.
Qualidade dos Dados: Dados de interação do mundo real (como o DECODE) são superiores aos dados sintéticos ou derivados de Git para treinar modelos para lidar com edições manuais de código. Mesmo modelos pequenos ajustados com dados de edição de alta qualidade do mundo real podem superar modelos de fronteira muito maiores.

Os autores concluem que os futuros assistentes de programação por IA exigem novos paradigmas de modelagem e avaliação que considerem explicitamente a interação do desenvolvedor, a personalização e a natureza iterativa da edição de código.