Un cambio de ritmo en la plataforma donde vive el código
El 28 de octubre de 2026, GitHub publicó la edición de este año de su informe anual Octoverse y colocó en el centro del relato una cifra que resume mejor que cualquier eslogan el momento que atraviesa la industria del software: los agentes de inteligencia artificial iniciaron más del 40 % de los pull requests creados en la plataforma durante septiembre de 2026. Seis meses antes, en marzo, esa proporción se situaba en torno al 17 %. En términos absolutos, hablamos de unos 110 millones de pull requests abiertos por agentes en un solo mes, una escala que hace unos años habría parecido una proyección de ciencia ficción y que hoy es una estadística de operaciones.
La noticia no es únicamente que haya más código generado por máquinas. Lo verdaderamente relevante es lo que ocurre después de que el agente abre su propuesta de cambio: alguien tiene que leerla, entenderla, probarla y decidir si entra en la rama principal. Esa tarea sigue siendo, en su inmensa mayoría, humana. El informe plantea por eso que el centro de gravedad del trabajo de ingeniería se desplaza desde escribir hacia revisar, y que la revisión de código se convierte en el nuevo cuello de botella del ciclo de desarrollo.
El dato circuló con rapidez entre directivos y desarrolladores, y lo citó el propio Satya Nadella, consejero delegado de Microsoft, empresa propietaria de GitHub. Que el máximo responsable de la compañía matriz lo utilizara como prueba del avance de la IA aplicada al desarrollo da una idea de hasta qué punto la cifra se ha convertido en un indicador estratégico, no solo técnico.
En este artículo repasamos qué dice exactamente el informe, cómo se interpreta la cifra, por qué GitHub la considera un suelo y no un techo, qué ocurre con la revisión de código, qué antecedentes ayudan a entender el fenómeno y qué pueden hacer los equipos para no ahogarse en una marea de propuestas automáticas. Hemos dejado fuera deliberadamente las tasas de fusión de esas propuestas, porque las cifras que circulan difieren de una lectura a otra y no hemos podido confirmarlas de forma consistente.
Qué dice la cifra y qué no dice
Conviene empezar por precisar el alcance del dato. Según el informe, en septiembre de 2026 los agentes de IA originaron más del 40 % de los pull requests de la plataforma, frente al 17 % de marzo. El salto es de más del doble en medio año, y se traduce en torno a 110 millones de pull requests iniciados por agentes en septiembre. Si se compara con el volumen de seis meses atrás, el crecimiento en términos absolutos es todavía más pronunciado, porque la plataforma entera registró más actividad, de modo que el numerador y el denominador crecieron a la vez.
Es importante entender qué significa “iniciar” un pull request. Un agente que inicia uno es aquel que, ante una tarea asignada o detectada, crea la rama, escribe los cambios, los empaqueta y abre la propuesta de integración. Eso no equivale a que el agente haya decidido de forma autónoma qué construir: en la mayoría de los casos, un humano formuló una petición, asignó una incidencia o configuró una automatización, y el agente ejecutó. La autoría intelectual del cambio, el criterio sobre qué merece existir en el producto, sigue recayendo en personas. Lo que cambia es quién teclea.
Tampoco dice la cifra nada sobre la calidad de esas propuestas. Un pull request puede ser una corrección de una línea o una refactorización de miles; puede resolver un problema real o ser ruido generado por una tarea mal definida. Contar propuestas es contar actividad, no valor. Por eso quienes leen estas estadísticas con cuidado insisten en separar tres planos: cuántas propuestas se abren, cuántas se aceptan y cuánto de lo aceptado aporta algo duradero al producto.
Por último, hay que recordar que se trata de un porcentaje sobre pull requests, no sobre líneas de código ni sobre commits. Un agente puede abrir muchas propuestas pequeñas y repetitivas, como actualizaciones de dependencias o arreglos de estilo, que elevan el recuento sin cambiar de forma proporcional la cantidad de lógica nueva que llega a producción. La lectura prudente es que la cifra mide un cambio de hábitos, no una sustitución de ingenieros.
Un suelo, no un techo: la limitación de medir lo detectable
Uno de los matices más interesantes del informe es que GitHub considera el 40 % un mínimo. La razón es metodológica: la plataforma solo puede contar los agentes que es capaz de identificar. Cuando una herramienta firma sus commits, usa una cuenta de bot reconocible o deja marcas inequívocas en la propuesta, el recuento es fiable. Pero existen muchos flujos en los que un desarrollador pide a un asistente que escriba un cambio en su máquina local, lo revisa por encima y lo sube con su propio usuario y su propia firma. Para la plataforma, ese pull request parece humano, aunque buena parte del trabajo lo haya hecho una máquina.
Esto implica que la cifra publicada captura, sobre todo, el trabajo de agentes que operan de forma visible y delegada: los que reciben una incidencia, trabajan en segundo plano y devuelven una propuesta completa. Queda fuera una zona gris enorme de código asistido que se mezcla sin etiquetas con la producción humana. Cuánto pesa esa zona es imposible de saber con precisión, y de ahí que el porcentaje real de contribuciones influidas por IA sea, casi con seguridad, superior al que se publica.
Esta limitación tiene consecuencias prácticas para quien quiera sacar conclusiones. Primero, no es sensato comparar de forma rígida la cifra de 2026 con la de años anteriores como si el método de detección hubiera permanecido idéntico: a medida que las herramientas se vuelven más visibles, o más ocultas, la medición cambia. Segundo, las organizaciones que quieran saber cuánto código generado por IA entra en sus repositorios no pueden depender de las estadísticas de la plataforma; necesitan sus propias convenciones de etiquetado y trazabilidad.
Tercero, y quizá más importante, la ambigüedad subraya un problema de gobernanza. Si ni siquiera la plataforma que aloja el código puede saber con exactitud quién lo escribió, la responsabilidad sobre lo que se fusiona recae por completo en quien aprueba. La procedencia del cambio importa menos que el criterio con el que se revisa, y ese criterio se ejerce siempre en el mismo punto: la revisión.
Del 17 % al 40 %: cómo se llegó en seis meses
Para entender un crecimiento tan rápido hay que mirar varios factores que se han reforzado entre sí. El primero es la madurez de los propios agentes. Los asistentes de hace dos años completaban líneas o funciones sueltas; los actuales son capaces de leer un repositorio, planificar una secuencia de pasos, ejecutar pruebas, corregir sus errores y entregar un conjunto coherente de cambios. Quien quiera profundizar en qué hay realmente detrás de ese salto puede leer cómo funcionan los agentes de IA más allá del modelo, donde se explica que el rendimiento depende tanto del bucle de herramientas, memoria y verificación como del modelo de lenguaje en sí.
El segundo factor es la integración. Cuando el agente vive dentro de la misma plataforma donde se gestionan las incidencias, las ramas, las acciones de integración continua y las revisiones, el coste de usarlo baja drásticamente. Asignar una tarea a un agente pasa a ser tan sencillo como asignársela a un compañero: un clic, una etiqueta, un comentario. Esa fricción casi nula explica buena parte de la adopción, porque transforma una capacidad impresionante en un hábito cotidiano.
El tercer factor es económico. Los costes de inferencia han caído y los modelos más pequeños y rápidos permiten ejecutar tareas rutinarias a un precio asumible. La tendencia de llevar parte de la inteligencia al propio equipo del desarrollador, como se vio con la ejecución local de un modelo de código dentro de GitHub Copilot, abre la puerta a que más tareas se deleguen sin el freno del coste por llamada ni de la latencia.
El cuarto factor es cultural. Tras un periodo de escepticismo, muchos equipos han pasado de probar los agentes en tareas marginales a confiarles trabajo de mantenimiento recurrente: actualizar dependencias, migrar versiones, añadir pruebas, corregir avisos del analizador estático, documentar. Son labores donde el criterio humano es necesario pero el esfuerzo de ejecución es tedioso, y donde la delegación resulta más natural. Una vez que un equipo comprueba que funciona en ese terreno, el siguiente paso es ampliar el perímetro.
Por qué la revisión se convierte en el cuello de botella
Aquí está el núcleo del argumento del informe. Cuando escribir código se abarata, el recurso escaso deja de ser la capacidad de producir cambios y pasa a ser la capacidad de validarlos. Un desarrollador humano puede escribir, con esfuerzo, un puñado de pull requests al día y revisar otro puñado. Un agente puede abrir decenas en paralelo sin cansarse. Si la capacidad de revisión no crece al mismo ritmo, se forma una cola, y esa cola es el cuello de botella del que habla GitHub.
Revisar bien es más costoso de lo que parece. No consiste en leer las líneas modificadas, sino en reconstruir la intención, comprobar que el cambio resuelve el problema correcto, evaluar sus efectos secundarios, verificar que encaja con la arquitectura existente y asegurarse de que no introduce vulnerabilidades ni deuda oculta. Con código escrito por un compañero, el revisor cuenta con contexto compartido: conoce al autor, sus costumbres y sus puntos débiles. Con un agente, ese contexto no existe, y el revisor debe desconfiar de forma más sistemática.
Además, el código generado por modelos tiene una característica incómoda: suele ser plausible. Compila, parece razonable, sigue el estilo del proyecto y viene acompañado de una descripción pulida. Esa apariencia de corrección reduce la vigilancia del revisor y puede ocultar errores sutiles de lógica, suposiciones erróneas sobre el dominio o dependencias innecesarias. Cuanto más fluido es el texto del agente, más disciplina se necesita para no aprobar por inercia.
Existe también un efecto psicológico bien documentado en cualquier entorno de automatización: la fatiga de aprobación. Cuando llegan decenas de propuestas similares, correctas en su mayoría, el revisor tiende a aprobar con rapidez y a bajar la guardia justo cuando aparece la que sí tiene un problema. La sobrecarga no solo retrasa la entrega; degrada la calidad del propio acto de revisar.
Este diagnóstico enlaza con una reflexión que ya habían planteado voces veteranas de la ingeniería de software. Robert C. Martin, conocido como Uncle Bob, explicó en su momento sus dudas sobre qué significa dejar de leer el código que escriben las máquinas, una postura que se analiza en por qué Uncle Bob dejó de leer código generado. Su planteamiento, discutible para unos y provocador para otros, pone sobre la mesa la pregunta incómoda que ahora se vuelve masiva: si el volumen supera la capacidad de lectura, ¿qué sustituye a la lectura?
Los números detrás del volumen: lo que implican 110 millones de propuestas
Conviene dimensionar la cifra. Ciento diez millones de pull requests en un mes equivalen a más de tres millones y medio por día, o a decenas de miles por minuto. Aunque la gran mayoría se concentre en repositorios privados de empresas y en proyectos con automatizaciones, el orden de magnitud obliga a replantear la infraestructura de revisión, de integración continua y de ejecución de pruebas.
Cada pull request dispara, normalmente, una batería de comprobaciones: compilación, pruebas unitarias, análisis estático, escaneo de dependencias, a veces pruebas de integración o despliegues de previsualización. Multiplicar por decenas de millones el número de propuestas significa multiplicar el consumo de recursos de cómputo. No es casual que en el mismo periodo las plataformas de desarrollo hayan hablado de ampliar su capacidad de ejecución: el trabajo de los agentes no solo genera revisión humana, también genera carga de máquinas que verifican a otras máquinas.
Desde el punto de vista de un equipo concreto, el efecto se nota de otra manera. Un repositorio que antes recibía diez propuestas diarias puede pasar a recibir cincuenta si se activan agentes sobre el backlog de incidencias. Si el equipo no ha ajustado sus procesos, la bandeja de revisión se desborda en cuestión de días. Y la tentación de resolverlo aprobando más rápido es precisamente la que erosiona la calidad.
Otro efecto del volumen es la competencia entre propuestas. Varios agentes, o el mismo agente lanzado varias veces, pueden tocar los mismos archivos, generando conflictos de fusión y cambios redundantes. La coordinación, que antes era una cuestión de comunicación entre personas, pasa a ser un problema de orquestación entre procesos automáticos, con reglas de prioridad, bloqueos y límites de concurrencia.
El papel de Microsoft y la lectura estratégica
Que Satya Nadella citara la cifra no es un detalle menor. Microsoft compró GitHub en 2018 y ha convertido a Copilot en una de las piezas centrales de su estrategia de inteligencia artificial para desarrolladores. Un dato que muestra que más de cuatro de cada diez propuestas de cambio nacen de agentes sirve como argumento de adopción: señala que la herramienta ha dejado de ser un complemento opcional y se ha integrado en el flujo de trabajo de millones de personas.
Conviene, no obstante, separar el hecho de la valoración. El hecho es que la plataforma registra ese porcentaje de propuestas iniciadas por agentes detectables. La valoración, que esto demuestra un aumento de productividad o una transformación irreversible de la profesión, es una interpretación con intereses comerciales evidentes por parte de quienes venden las herramientas. Es razonable tomar el dato como indicador sólido de adopción y, al mismo tiempo, mantener una cautela crítica sobre las conclusiones que se extraen de él.
El mercado, además, observa con atención. Si la revisión es el cuello de botella, el siguiente terreno de competencia son las herramientas que ayudan a revisar: asistentes que resumen cambios, que priorizan propuestas por riesgo, que verifican automáticamente propiedades del código o que comprueban el comportamiento ejecutando el software. La paradoja es evidente: se usa IA para acelerar la producción y, a continuación, más IA para absorber el exceso de producción. Si ese ciclo mejora de verdad la calidad o solo traslada el problema es una de las grandes preguntas abiertas.
Antecedentes: de la autocompletación al agente autónomo
Para valorar el 40 % conviene recordar de dónde venimos. Hace pocos años, la asistencia de IA en programación se limitaba a sugerir la siguiente línea o bloque mientras el desarrollador escribía. El humano seguía llevando el volante, y el pull request era siempre obra suya aunque una parte del texto hubiera sido sugerida.
Después llegaron los chats integrados en el editor, capaces de explicar fragmentos, proponer refactorizaciones y generar funciones a partir de descripciones. El desarrollador seguía copiando, pegando y comprobando. El tercer escalón fue el modo agente dentro del editor, donde el asistente edita varios archivos, ejecuta comandos y reacciona a los errores. Finalmente, el escalón que explica las cifras de ahora: los agentes asíncronos que trabajan fuera del editor, en entornos aislados, a partir de una tarea asignada, y que devuelven un pull request listo para revisión.
Cada escalón desplazó un poco más el trabajo del desarrollador desde la escritura hacia la supervisión. En la autocompletación, la supervisión era instantánea y línea por línea. En el agente asíncrono, la supervisión se concentra al final y sobre un conjunto de cambios más grande, lo que hace más difícil detectar un fallo y más caro corregirlo. El informe de GitHub no inventa esta tendencia, pero la cuantifica y le pone fecha: entre marzo y septiembre de 2026 se cruzó un umbral simbólico.
Qué significa para el día a día de un equipo de ingeniería
Para quienes trabajan en un equipo, el cambio se traduce en una redefinición de tareas. El desarrollador deja de ser principalmente un escritor de código y pasa a ser, cada vez más, un especificador, un revisor y un integrador. Especificar bien una tarea, con criterios de aceptación claros, ejemplos y límites, determina en gran medida la calidad de lo que devuelve el agente. Una incidencia ambigua produce una propuesta ambigua, y el coste de esa ambigüedad lo paga el revisor.
El revisor, por su parte, necesita habilidades que no siempre se cultivan: leer con rapidez código que no ha escrito nadie conocido, detectar patrones típicos de error de los modelos, exigir pruebas que demuestren el comportamiento y negarse a aprobar lo que no entiende. Esa última capacidad, decir que no a una propuesta bien presentada pero insuficiente, es quizá la más valiosa y la más difícil de mantener bajo presión de plazos.
También cambia la relación con las personas menos experimentadas. Quienes empiezan en la profesión aprendían históricamente escribiendo código sencillo y recibiendo revisiones de sus compañeros. Si las tareas sencillas pasan a los agentes, la ruta de aprendizaje se estrecha, y las organizaciones tendrán que decidir cómo formar a los nuevos ingenieros en el criterio de revisión sin que hayan pasado antes por el oficio de escribir a mano. Es un desafío de carrera profesional con implicaciones a largo plazo para la cantera de talento.
Por último, aparece el tema de la responsabilidad. Cuando un cambio defectuoso llega a producción, el hecho de que lo haya escrito un agente no desplaza la responsabilidad: la tiene quien aprobó la fusión y la organización que definió el proceso. Los equipos maduros están dejando por escrito quién responde de qué, qué tipos de cambio pueden fusionarse con revisión ligera y cuáles exigen la mirada de un especialista.
Estrategias para que la revisión no sea el atasco
Frente al cuello de botella hay respuestas prácticas que los equipos ya ensayan. La primera es reducir el tamaño de lo que se revisa. Los pull requests pequeños, acotados a un único propósito, son más fáciles de entender y de rechazar. Configurar a los agentes para que dividan el trabajo en cambios atómicos, en lugar de entregar una modificación monolítica, mejora la capacidad de supervisión de forma inmediata.
La segunda es endurecer las comprobaciones automáticas antes de que un humano intervenga. Si la integración continua incluye pruebas robustas, análisis estático estricto, verificación de tipos y escaneo de seguridad, el revisor puede centrarse en lo que las máquinas no ven: la intención, el diseño y el encaje con el producto. Una propuesta que falla las pruebas ni siquiera debería llegar a una persona. En este sentido, pruebas automáticas como primera barrera se convierten en la inversión más rentable para absorber el volumen de los agentes.
La tercera es clasificar por riesgo. No todo cambio merece el mismo escrutinio: actualizar un número de versión en un archivo de documentación no es equiparable a modificar la lógica de autenticación o de pagos. Definir reglas que dirijan los cambios sensibles a revisores expertos y permitan un camino más ágil para los triviales evita tanto el atasco como la complacencia.
La cuarta es exigir al agente que explique y demuestre. Una buena propuesta automática debería incluir qué problema resuelve, qué alternativas descartó, qué pruebas añadió y cómo se verificó el resultado. Cuando la descripción es un resumen vago, es una señal de alarma. Exigir evidencias ejecutables, no solo texto convincente, desplaza la carga de la prueba hacia quien propone, que en este caso es la máquina.
La quinta es limitar la concurrencia. Tener cincuenta agentes trabajando en paralelo no sirve de nada si el equipo solo puede revisar diez propuestas al día. Ajustar el número de tareas delegadas a la capacidad real de revisión, y no a la capacidad de generación, es contraintuitivo pero necesario. La velocidad del sistema completo la marca su eslabón más lento.
Riesgos: seguridad, deuda técnica y confianza
Más propuestas automáticas implican más superficie de riesgo. En seguridad, un agente con permisos amplios puede introducir dependencias comprometidas, exponer secretos en archivos de configuración o implementar patrones vulnerables que parecen correctos. Los ataques que buscan manipular a un agente mediante instrucciones ocultas en una incidencia, un comentario o un archivo del repositorio son una amenaza real: si el agente obedece a texto que no debería, puede producir cambios maliciosos que luego pasan por una revisión superficial.
La deuda técnica es el riesgo silencioso. Un agente optimiza para resolver la tarea presente, no para mantener la coherencia del sistema a lo largo de años. Si cada propuesta añade una solución local ligeramente distinta, el código se llena de duplicaciones, abstracciones inconsistentes y soluciones que nadie en el equipo entiende del todo. La velocidad de hoy puede convertirse en lentitud de mañana cuando haya que modificar un sistema que nadie escribió con intención.
La confianza es el tercer eje. Si un equipo aprueba por costumbre y descubre tarde un fallo grave, la reacción habitual es un péndulo hacia la desconfianza total, que frena toda la automatización. Construir confianza de forma gradual, con métricas claras de qué porcentaje de propuestas se rechazan, por qué motivo y con qué consecuencias, permite calibrar hasta dónde delegar. Sin datos propios, cada equipo decide por intuición o por moda.
Existe, además, un riesgo de medición equivocada. Si las organizaciones celebran el número de propuestas abiertas por agentes como señal de productividad, incentivan la cantidad sobre el valor. Una métrica de actividad convertida en objetivo deja de ser buena métrica. Lo sensato es medir tiempos de ciclo de extremo a extremo, defectos que escapan a producción y esfuerzo de revisión por cambio fusionado.
Casos comparables: cuando la producción supera a la verificación
La situación recuerda a otros momentos de la historia de la tecnología en los que un paso de la cadena se abarató y el siguiente se encareció en términos relativos. La llegada de la integración continua obligó a invertir en pruebas automáticas porque integrar a diario exponía los errores con rapidez. La popularización de los despliegues frecuentes forzó mejoras en observabilidad y reversión. En cada caso, acelerar una etapa trasladó la presión a la siguiente.
Algo parecido ocurrió con el correo electrónico y el contenido generado de forma masiva: cuando enviar un mensaje cuesta casi nada, el filtrado se vuelve el problema central. La analogía no es perfecta, porque aquí las propuestas no son spam sino trabajo potencialmente útil, pero el patrón estructural es el mismo. Un sistema donde producir es gratis y verificar es caro acaba dominado por la capacidad de verificación.
En el software de código abierto ya se han visto síntomas. Mantenedores de proyectos populares han descrito la avalancha de contribuciones automáticas de calidad desigual, algunas útiles y otras que consumen tiempo sin aportar. Algunos proyectos han optado por políticas explícitas sobre contribuciones generadas por IA, exigiendo que se declare su uso o limitando ciertos tipos de aportación. La cifra de Octoverse sugiere que ese fenómeno, antes localizado, es ahora una característica general del ecosistema.
Situación actual de la historia
A mediados de noviembre de 2026, el informe lleva más de dos semanas publicado y su cifra principal se ha asentado como referencia en el debate sobre el futuro del desarrollo. El porcentaje de más del 40 % de pull requests de septiembre iniciados por agentes, la comparación con el 17 % de marzo y los alrededor de 110 millones de propuestas mensuales son los datos que más se repiten. GitHub mantiene que el porcentaje es un mínimo, dado que solo computa agentes detectables, y no ha presentado una estimación del volumen no identificado.
Las tasas de aceptación de esas propuestas son el aspecto más disputado: las cifras que circulan varían según el periodo de comparación y la forma de medir, y por eso no se recogen aquí como un dato establecido. Lo que sí parece claro es que la discusión de fondo ha pasado de si los agentes pueden contribuir de manera útil a cómo se gobierna una contribución a esta escala.
Mientras tanto, las plataformas y los proveedores de herramientas siguen lanzando funciones orientadas a la revisión: resúmenes automáticos, priorización de propuestas, comprobaciones adicionales y controles de permisos para agentes. Los equipos, por su parte, experimentan con políticas de revisión por niveles de riesgo y con límites de concurrencia. No hay todavía un consenso sobre el modelo ideal, y es probable que las prácticas se asienten a lo largo de los próximos meses a medida que se acumule experiencia.
Qué puede venir después
Si la tendencia se mantiene, es plausible que la proporción siga creciendo, aunque la curva no tiene por qué ser lineal. Hay límites naturales: la cantidad de tareas bien definidas y delegables es finita, y la capacidad de revisión impone un techo práctico. Es probable que veamos una fase de ajuste en la que las organizaciones descubran que más propuestas no equivale a más producto, y que el valor está en elegir bien qué delegar.
También cabe esperar una evolución en la forma de revisar. Si la lectura línea por línea no escala, ganarán peso otras formas de verificación: pruebas generadas y revisadas con más rigor, verificación formal de propiedades críticas, entornos de previsualización en los que comprobar el comportamiento real y revisiones centradas en las especificaciones más que en el texto del código. La pregunta de fondo es qué constituye una evidencia suficiente de que un cambio es correcto cuando nadie lo ha leído completo.
Y se abrirá, probablemente, una conversación más amplia sobre estándares: etiquetado obligatorio del origen de los cambios, registros de auditoría de lo que hace cada agente, límites de permisos por defecto y responsabilidad compartida entre quien configura el agente, quien lo proporciona y quien aprueba. Esa conversación afecta tanto a empresas como a proyectos abiertos, y condicionará cómo se construye software en la segunda mitad de esta década.
Lecciones para desarrolladores y responsables técnicos
La primera lección es que el valor profesional se desplaza hacia el criterio. Saber escribir código sigue siendo importante, pero la capacidad de juzgar si un cambio es correcto, necesario y mantenible gana peso. Quien desarrolle esa capacidad estará mejor situado, con independencia de cuántas líneas escriba él mismo.
La segunda es que conviene medir lo que importa. En lugar de celebrar el número de propuestas automáticas, los responsables técnicos deberían observar la salud del sistema completo: tiempos de entrega, tasa de defectos, carga de revisión y satisfacción del equipo. Una cola de revisión creciente es una señal de que se está delegando más de lo que se puede absorber.
La tercera es que la automatización debe diseñarse con la verificación en mente. Cada tarea que se entrega a un agente debería acompañarse de los mecanismos que permitan comprobar el resultado de forma barata: pruebas, tipos, linters, entornos de prueba. Una tarea sin forma de verificarla rápidamente es una tarea que probablemente no conviene delegar todavía.
La cuarta es que la transparencia sobre el uso de IA ayuda a todos. Declarar qué cambios los ha generado un agente permite a los revisores ajustar su nivel de atención y a la organización aprender de sus resultados. Esconder el origen, aunque sea por comodidad, empobrece los datos con los que se toman decisiones y alimenta la limitación que el propio informe reconoce al medir solo lo detectable.
La quinta es que la formación debe adaptarse. Los equipos que inviertan en enseñar a revisar, a especificar y a desconfiar con método construirán una ventaja frente a los que traten a los agentes como una caja mágica. La buena noticia es que esas habilidades, bien cultivadas, mejoran también la colaboración entre personas.
Conclusiones
El informe Octoverse 2026 de GitHub, publicado el 28 de octubre, deja una cifra difícil de ignorar: los agentes de IA iniciaron más del 40 % de los pull requests de septiembre de 2026, unos 110 millones, frente al 17 % de marzo. GitHub la considera un mínimo porque solo contabiliza agentes detectables, y Satya Nadella la citó como prueba del avance de la IA en el desarrollo de software.
Más allá del titular, el mensaje de fondo es que el cuello de botella se ha movido. Producir cambios es ahora barato y rápido; entenderlos, validarlos y decidir si entran en el producto sigue siendo caro y humano. La revisión de código, antes una tarea más del flujo, se convierte en el recurso que limita la velocidad real de los equipos y en el lugar donde se juega la calidad del software.
Las respuestas pasan por cambios concretos: pull requests pequeños, comprobaciones automáticas exigentes, clasificación por riesgo, límites a la concurrencia de agentes y una cultura que valore decir que no. También por una dosis de prudencia ante los números: la cifra mide adopción y actividad, no valor, y otros datos, como las tasas de aceptación, aparecen con valores distintos según quién los calcule, por lo que conviene no darlos por cerrados.
La industria se encuentra en una transición en la que escribir código deja de ser el centro del oficio y supervisar, especificar y verificar pasan a serlo. Los equipos que entiendan antes que el problema ya no es generar sino confiar con fundamento serán los que aprovechen esta ola sin quedar sepultados por ella.
