🤖 machine learning

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

Este artículo presenta DECODE, un conjunto de datos de 53.600 ediciones en el IDE de código generado por IA en el mundo real de más de 1.000 desarrolladores, el cual revela que la mayoría de las modificaciones ocurren dentro de los 15 minutos posteriores a la aceptación y demuestra que el ajuste fino de modelos más pequeños con estos datos supera significamente a los LLM de vanguardia en la predicción de ediciones de código.

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

Publicado 2026-07-29

📖 6 min de lectura🧠 Análisis profundo

CC BY 4.0

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

Artículo original bajo licencia CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta es una explicación generada por IA del artículo a continuación. No ha sido escrita ni avalada por los autores. Para mayor precisión técnica, consulte el artículo original. Leer descargo de responsabilidad completo

Imagina que le estás enseñando a un robot a cocinar. Le muestras un libro de recetas e intenta preparar un plato. A veces, el robot lo hace perfecto. Pero a menudo, añade demasiada sal, olvida el ajo o usa una cuchara en lugar de un batidor. En el mundo de la informática, este robot es un "asistente de programación de IA", y los platos son líneas de código. Durante mucho tiempo, los científicos intentaron enseñar a estos robots mostrándoles recetas terminadas (llamadas "Git commits"): los platos finales y perfectos que llegan a los libros de cocina. Pero esto es como intentar aprender a cocinar mirando solo la comida en el plato, ignorando la cocina desordenada, la tostada quemada y las correcciones frenéticas del chef.

La verdadera magia (y el verdadero desorden) ocurre en medio. Cuando un chef humano prueba una sopa y dice: "No, le falta más pimienta", o "En realidad, tira eso y empieza de nuevo", eso es una "edición de código". Hasta ahora, no teníamos una buena forma de observar al chef haciendo esto. Solo veíamos el resultado final. Este artículo se sumerge en esa cocina desordenada y hermosa. Se pregunta: ¿Cómo arreglan los humanos los errores de la IA? ¿Hacen un pequeño ajuste o desechan todo por completo? ¿Y podemos enseñar al robot a predecir estos arreglos antes de que ocurran?

El Gran Detective de Código: DECODE

Los investigadores detrás de este estudio se dieron cuenta de que, para que la IA sea mejor escribiendo código, debían dejar de mirar el producto terminado y empezar a observar el proceso. Crearon un nuevo y masivo conjunto de datos llamado DECODE (Developer Edits of Code Dataset). Piensa en DECODE como un sistema de cámaras de seguridad gigantes y de alta definición instalado en los IDEs (los espacios de trabajo digitales) de más de 1,000 desarrolladores reales. En lugar de solo guardar el código final, este sistema grababa cada pulsación, cada borrado y cada reescritura que un desarrollador realizaba después de que la IA sugería un fragmento de código.

Recolectaron 53,600 de estas sesiones de edición del mundo real, principalmente en Python, TypeScript y JavaScript. Es como tener una biblioteca de 53,600 historias sobre cómo los humanos y los robots discuten, llegan a acuerdos y colaboran para construir software.

Lo que encontraron: La regla de los 15 minutos y el "cubo de la basura"

Cuando el equipo analizó los datos, encontró algunos patrones sorprendentes sobre cómo los humanos tratan las sugerencias de la IA.

Primero, descubrieron una estricta regla de los 15 minutos. La mayor parte de la edición ocurre muy rápido. Si un desarrollador va a cambiar el código de la IA, suele hacerlo dentro de los primeros 15 minutos tras aceptar la sugerencia. Después de eso, el código suele quedarse sin cambios.

Segundo, descubrieron que los humanos son sorprendentemente severos. En aproximadamente el 31% de los casos, el desarrollador no solo retocó el código, sino que borró toda la sugerencia de la IA y empezó desde cero. Es como si la IA te entregara un sándwich y tú lo tiraras inmediatamente a la basura porque el pan estaba ligeramente mal. Los datos sugieren que si una sugerencia de la IA no se ajusta perfectamente a la intención del desarrollador desde el principio, a menudo está destinada a ser abandonada.

Sin embargo, cuando los humanos sí conservan el código, no cambian mucho. Los datos muestran que para el código que sobrevive, los desarrolladores suelen mantener alrededor del 63% de la sugerencia original de la IA. Tienden a añadir muy poco de su propio código nuevo (solo cerca del 20% del código final es contenido nuevo añadido por el humano). Esto significa que los desarrolladores dependen mucho de la IA, pero son muy exigentes con la calidad inicial.

Los investigadores también notaron un orden específico en cómo la gente arregla las cosas. Es como una lista de verificación:

La comprobación de "¿Es esto siquiera utilizable?": Primero, deciden si quieren conservar el código en absoluto. Si no, lo borran.
La fase de "Corregir los errores": Luego, corrigen errores de sintaxis o de legibilidad.
La fase de "Hacerlo mío": Después, cambian nombres de variables o números para que se ajusten a sus necesidades específicas.
La fase de "Cambiar el plan": Finalmente, si siguen trabajando en ello, podrían cambiar lo que el código realmente hace.

Enseñando al robot a leer la mente

La segunda gran parte del artículo fue una prueba: ¿Podemos enseñar a un modelo de IA más pequeño y de código abierto a predecir estos cambios mejor que los modelos gigantes y superinteligentes de "frontera"?

Normalmente, los modelos de IA más grandes y costosos son considerados los mejores en todo. Pero aquí, los investigadores tomaron un modelo más pequeño (uno de 3 mil millones de parámetros, que es diminuto comparado con los gigantes) y lo entrenaron específicamente con el conjunto de datos DECODE. Le enseñaron a mirar una sugerencia de la IA y adivinar: "¿El humano borrará esto? ¿Lo retocará? ¿O lo dejará tal cual?".

El resultado fue impactante. El modelo pequeño, tras aprender de los datos de edición del mundo real, se volvió significativamente mejor prediciendo los cambios que los enormes modelos de última generación que nunca habían visto estos datos específicos.

Para adivinar cómo sería el código final, la precisión del modelo pequeño mejoró en 0.17 (un salto enorme en este campo).
Para adivinar si el código sería cambiado, también mejoró en 0.17.

Esto sugiere que tener la "experiencia" adecuada (datos de edición del mundo real) es más importante que simplemente tener un cerebro más grande. Es como un joven chef que ha visto miles de programas de cocina (los datos) y puede saber cómo arreglar un plato mejor que un chef famoso que solo ha cocinado comidas perfectas en un laboratorio.

La conclusión: Se trata del humano, no solo del código

El artículo concluye que debemos dejar de tratar la generación de código por IA como un problema matemático donde el único objetivo es la "corrección". El objetivo real es la "alineación". El código debe ajustarse a la intención del humano, o el humano simplemente lo desechará.

Los autores sugieren que los futuros asistentes de IA no deberían limitarse a intentar escribir el código perfecto al primer intento. En su lugar, deben ser entrenados para entender el proceso de edición. Necesitan aprender que los humanos suelen borrar cosas rápidamente, que arreglan errores antes de cambiar funciones y que es más probable que conserven el código que es fácil de retocar.

Al utilizar conjuntos de datos como DECODE, podemos construir una IA que no solo escriba código, sino que escriba código que los humanos realmente quieran conservar. Es un cambio de preguntar "¿Es este código correcto?" a preguntar "¿Es este código algo que un humano pueda hacer suyo fácilmente?". Y los datos sugieren que si enseñamos a nuestra IA a entender la desordenada ventana de edición de 15 minutos, finalmente podríamos obtener un robot que cocine una comida que estemos felices de comer.

Resumen Técnico: Aprendizaje a partir de 53.6K Ediciones de Código Generado por IA en el Mundo Real

Declaración del Problema

A pesar de la adopción generalizada de los asistentes de programación basados en IA, el código generado es frecuentemente imperfecto, conteniendo errores o desalineándose con estilos de codificación específicos. En consecuencia, los desarrolladores deben modificar manualmente el código generado por la IA, ya sea mediante la edición directa o mediante el re-prompting del modelo. Los Modelos de Lenguaje Extensos (LLMs) actuales se entrenan principalmente en datos de Git disponibles públicamente (por ejemplo, commits y pull requests) para aprender la edición de código. Sin embargo, los datos de Git representan solo el estado final y exitoso del código, careciendo de los pasos intermedios, el orden temporal y el contexto del proceso de edición real. Esta brecha limita la capacidad de los LLMs para predecir o modelar cómo los desarrolladores interactúan con y modifican las completaciones de la IA en tiempo real. Además, los conjuntos de datos existentes suelen depender de datos sintéticos, entornos de laboratorio o ediciones instruidas, fallando al capturar los matices de las ediciones de código manuales y reales del contenido generado por IA.

Metodología

1. Construcción del Conjunto de Datos: DECODE

Para abordar la falta de datos de edición realistas, los autores introducen DECODE (Developer Edits of Code Dataset), una colección de 53.6K ediciones de código de la IA en el IDE en el mundo real.

Fuente: Los datos se recolectaron de una extensión de Visual Studio Code (VS Code) utilizada por más de 1,000 desarrolladores. La extensión captura las completaciones de IA y instantáneas (snapshots) del archivo de trabajo cada vez que un desarrollador hace una pausa de un segundo.
Alcance: El conjunto de datos cubre Python, TypeScript y JavaScript, abarcando 20 LLMs diferentes y diversos contextos de desarrollo (por ejemplo, desarrollo web, análisis de datos, aprendizaje automático).
Pipeline de Extracción:
1. Identificación: Emparejamiento de archivos de código que contienen completaciones de IA aceptadas ( $y_0$ ) con instantáneas subsecuentes ( $y_t$ ).
2. Extracción: Uso de git diff --histogram para aislar líneas específicas añadidas, eliminadas o modificadas en relación con la completación original. Esto redujo los datos brutos de 6.5 millones de líneas a 772.2K líneas directamente relevantes para las ediciones.
3. Limpieza: Validación de trayectorias utilizando CodeBERTScore (umbral 0.68) para asegurar la relevancia y eliminación de datos malformados.
4. Privacidad: Aplicación de pipelines de redacción de PII (Starcoder/Stack y OpenAI Privacy Filter) para eliminar información de identificación personal.
Estadísticas: El conjunto de datos final comprende 5,831 trayectorias de edición de 1,141 desarrolladores, con una duración de trayectoria mediana de ~50 minutos y una mediana de 329 ediciones de Levenshtein por trayectoria.

2. Análisis del Comportamiento del Desarrollador

Los autores utilizaron DECODE para analizar cuándo, por qué y cómo los desarrolladores editan el código de la IA utilizando métricas como la proporción de código de IA restante, el código añadido por el desarrollador y el volumen total de edición.

Patrones Temporales: El 50% de las ediciones ocurren dentro de los primeros 50 minutos tras la aceptación, con una caída pronunciada después de los 15 minutos.
Tipos de Edición: Las ediciones se clasificaron en cuatro categorías: Personalización de código (10%), Mejora de calidad (14%), Cambio de funcionalidad (56%) y Eliminación de completaciones (9%).
Resultados: El 31% de las trayectorias resultan en la eliminación completa de la completación de la IA. La distribución del código restante es bimodal: los desarrolladores o bien mantienen el código con pocas modificaciones o lo descartan por completo.

3. Benchmarking de LLMs

El estudio evaluó la capacidad de los LLMs para predecir ediciones de código en dos tareas:

Clasificación: Predecir si una completación de IA será eliminada, permanecerá sin modificaciones o será modificada.
Generación: Predecir el estado final del código ( $y_t$ ) dada la completación de IA inicial ( $y_0$ ).
Modelos Probados: Se evaluaron modelos de frontera (ej. GPT-5.2, Claude Sonnet 4.6) y modelos de código abierto (ej. Qwen2.5-Coder, Llama3.2) en configuraciones de pocos disparos (few-shot) y tras el ajuste fino (fine-tuning) sobre DECODE usando LoRA.

Resultados Clave

1. Perspectivas sobre el Comportamiento del Desarrollador

Abandono Rápido: Los desarrolladores a menudo abandonan las completaciones de la IA rápidamente si no se alinean con su intención. El 23% de las trayectorias implican una eliminación inmediata, a menudo seguida de la escritura de su propia implementación por parte del desarrollador.
Baja Tasa de Adición: Los desarrolladores rara vez añaden código nuevo significativo a las completaciones de la IA; el 20% del código final es añadido por el desarrollador, y el 36% de las trayectorias contienen menos del 5% de nuevo código del desarrollador.
Edición Secuencial: Emerge un patrón común donde los desarrolladores primero deciden si mantener el código (eliminación), luego corrigen errores (calidad), adaptan a sus necesidades (personalización) y finalmente modifican la funcionalidad.

2. Mejoras de Rendimiento vía Fine-Tuning

Superioridad de Modelos Pequeños Ajustados: El ajuste fino de modelos de código abierto (3B y 7B parámetros) sobre DECODE superó significativamente a los modelos de frontera tanto en las tareas de clasificación como de generación.
- Clasificación: Los modelos de 3B ajustados lograron un F1 score de 0.42–0.45, superando a modelos de frontera como Claude Sonnet 4.6 (0.37) y GPT-5.2 (0.32).
- Generación: Los modelos ajustados mejoraron la similitud de Levenshtein en +0.15 a +0.22 sobre sus versiones base y superaron significativamente a los modelos de frontera (ej. +0.17 de mejora sobre los baselines de frontera).
Cantidad de Datos: El rendimiento mejoró a medida que los modelos fueron expuestos a más pasos de edición durante el entrenamiento (hasta 4 pasos), lo que sugiere que capturar la naturaleza secuencial de las ediciones es crucial.
Sin Degradación: El ajuste fino sobre DECODE no degradó las capacidades de generación de código en benchmarks estándar (HumanEval, MBPP); en algunos casos (Qwen2.5-Coder-3B), el rendimiento mejoró ligeramente.

Significado y Reivindicaciones

El artículo argumenta que los enfoques de aprendizaje automático centrados en el desarrollador son necesarios para la próxima generación de asistentes de programación de IA. Las conclusiones clave son:

Alineación sobre Corrección: Los benchmarks estándar se centran en la corrección del código (pass@k), pero la utilidad en el mundo real depende de qué tan bien el código se alinea con la intención y el contexto del desarrollador. Los desarrolladores a menudo descartan código "correcto" si no es fácilmente adaptable.
La Editabilidad como Métrica: La capacidad de que el código generado por IA sea fácilmente editable (editabilidad) es un factor crítico, aunque submedido. Los modelos futuros deberían ser capaces de detectar generaciones que probablemente serán descartadas.
Modelado Temporal: Los LLMs deben capturar la naturaleza secuencial y temporal de las ediciones de los desarrolladores (ej. las eliminaciones ocurren temprano, los cambios de funcionalidad ocurren más tarde). Entrenar sobre commits de Git brutos falla al capturar este proceso dinámico.
Calidad de los Datos: Los datos de interacción del mundo real (como DECODE) son superiores a los datos sintéticos o derivados de Git para entrenar modelos para manejar ediciones de código manuales. Incluso modelos pequeños ajustados con datos de edición de alta calidad del mundo real pueden superar a modelos de frontera mucho más grandes.

Los autores concluyen que los futuros asistentes de programación de IA requieren nuevos paradigmas de modelado y evaluación que contemplen explícitamente la interacción del desarrollador, la personalización y la naturaleza iterativa de la edición de código.