Toda empresa con software de más de cinco años tiene una lista pendiente de modernización: un servicio en Java 8 que nadie se atreve a tocar, un framework dos versiones mayores por detrás, una batería de tests sobre una librería obsoleta, un monolito que debió dividirse hace años. Estos proyectos se aplazan porque son caros, arriesgados y aburridos. Los agentes de programación con IA cambian la economía de la parte aburrida. No eliminan el riesgo. Esta guía muestra dónde ayuda la IA en la modernización, qué han publicado las grandes empresas sobre hacerlo a escala y un proceso paso a paso que mantiene el riesgo bajo control.

Lo que ha aprendido el sector

Varias organizaciones han publicado resultados concretos de migraciones asistidas por IA:

  • Google usó LLM en grandes migraciones internas de código, como cambiar los tipos enteros de los identificadores en una base de código enorme. Según su informe, aproximadamente el 80% de las modificaciones de código en los cambios integrados fueron escritas por la IA, y los ingenieros estimaron que el tiempo total de la migración se redujo alrededor de un 50% frente a hacerla a mano (Nikolov et al., 2025). Lo crucial: el pipeline combinaba ediciones del LLM con herramientas deterministas para localizar los puntos de cambio, builds y tests para validar, y revisión humana.
  • Airbnb migró miles de archivos de tests de React de Enzyme a React Testing Library con un pipeline basado en LLM con pasos automáticos de validación y reintento, y completó en semanas lo que se había estimado en más de un año de trabajo manual (Airbnb Engineering, 2025).
  • AWS ofrece en Amazon Q Developer transformaciones guiadas por agentes para actualizar versiones de Java y portar .NET, de nuevo combinando modelos con verificación de build y tests (documentación de AWS).

El patrón común en todos ellos: el LLM es una etapa dentro de un pipeline. Las herramientas deterministas encuentran qué cambiar, el modelo hace ediciones sensibles al contexto y los builds y tests deciden si un cambio se acepta. Nadie ha informado de éxitos con "pedirle a un chatbot que reescriba el servicio".

Tipos de modernización y cuánto ayuda la IA

Tipo Ejemplo Contribución de la IA
Actualización del runtime Java 8 → 21/25, Node 16 → 22, Python 3.8 → 3.12 Alta: ediciones mecánicas más corrección de errores de compilación y de tests
Actualización de framework Spring Boot 2 → 3, Angular → versión nueva, Odoo 16 → 18 Alta, combinada con recetas y notas de versión
Sustitución de librería Enzyme → RTL, Joda-Time → java.time, Moment → date-fns Muy alta: patrones de destino bien definidos
Migración de lenguaje Java → Kotlin, JavaScript → TypeScript Alta para la sintaxis, media para los modismos
Cambio de arquitectura Monolito → módulos o servicios Media: análisis y código repetitivo; el diseño es de las personas
Migración de plataforma 1C → Odoo, ERP a medida → estándar Media: mapeo de datos y extracción de lógica
Reescritura completa COBOL → Java Baja a media: lo difícil es descubrir el comportamiento

Cuanto más abajo en la tabla, más se trata de entender el comportamiento que de transformar la sintaxis, y más criterio humano requiere.

Paso 1: inventaría y entiende antes de cambiar nada

Empieza por el análisis. Los agentes son excelentes asistentes de investigación sobre código desconocido:

  • Inventario de dependencias y APIs. ¿Qué APIs obsoletas se usan, dónde y con qué frecuencia? Combina grep, las herramientas de build (mvn dependency:tree, gradle dependencies) y los resúmenes del agente.
  • Documentación del comportamiento. Pide al agente que documente cada módulo: entradas, salidas, efectos secundarios, llamadas externas, reglas de negocio implícitas. Revisa estos documentos con alguien que conozca el sistema; encontrará malentendidos a tiempo.
  • Mapa de riesgos. ¿Qué zonas no tienen tests, cambian con frecuencia o acumulan incidentes? Esas necesitan más cuidado.

Guarda los resultados en el repositorio (docs/modernization/). Se convierten en contexto para cada sesión posterior del agente y para las personas que se incorporen al equipo.

Paso 2: construye la red de seguridad, los tests de caracterización

No puedes cambiar con seguridad código cuyo comportamiento no puedes verificar. Antes de cualquier transformación, genera tests de caracterización que fijen el comportamiento actual de las zonas que vas a tocar. Es uno de los usos más valiosos de la IA en la modernización; el método se describe en detalle en tests unitarios generados con IA. Usa mutation testing para confirmar que los tests detectan realmente los cambios.

En servicios cuyo comportamiento externo importa más que su estructura interna, añade tests golden master a nivel de API: graba peticiones y respuestas del sistema actual y reprodúcelas contra el nuevo.

Paso 3: usa herramientas deterministas para la parte mecánica

No pidas a un LLM lo que una herramienta de refactorización hace de forma fiable. En proyectos JVM, OpenRewrite ofrece recetas probadas para actualizaciones como versiones de Java, Spring Boot 3, los namespaces de Jakarta EE y JUnit 5:

# Example: apply OpenRewrite's Spring Boot 3 upgrade recipe with Maven
mvn -U org.openrewrite.maven:rewrite-maven-plugin:run \
  -Drewrite.recipeArtifactCoordinates=org.openrewrite.recipe:rewrite-spring:RELEASE \
  -Drewrite.activeRecipes=org.openrewrite.java.spring.boot3.UpgradeSpringBoot_3_0

Existen herramientas similares en otros ecosistemas: codemods con jscodeshift o ts-morph para JavaScript, pyupgrade y LibCST para Python, el .NET Upgrade Assistant. Ejecútalas primero y deja al agente lo que quede: los errores de compilación, los tests que fallan y los sitios donde importa el contexto.

Paso 4: deja que el agente trabaje en lotes pequeños y verificados

El bucle de transformación que funciona:

  1. Elige una unidad pequeña: un módulo, un paquete o de 10 a 20 archivos.
  2. Da al agente el patrón de destino con ejemplos, las notas de versión y los comandos de build y test.
  3. El agente aplica los cambios e itera hasta que el build y los tests pasan.
  4. Una persona revisa el diff, centrándose en los cambios de comportamiento más que en la sintaxis.
  5. Haz merge y despliega tras un flag o en un canary si es posible.
  6. Repite.
Task: migrate package com.shop.billing from Joda-Time to java.time.

Rules:
- Follow docs/modernization/joda-to-javatime.md (mapping table + examples).
- Preserve time zone semantics exactly; billing uses Europe/Kyiv.
- Do not change public method signatures in this batch; add adapters if needed.
- After changes run: ./gradlew :billing:test :billing:pitest

Stop and ask if a conversion is ambiguous (e.g. LocalDate vs ZonedDateTime).

La regla de "para y pregunta" importa. La ambigüedad es el origen de los bugs silenciosos, y los agentes la resolverán con seguridad salvo que se les indique lo contrario. Mi flujo de trabajo general con agentes está en buenas prácticas de agentic coding.

Paso 5: despliega con el strangler fig, no con un big bang

Para cambios de arquitectura y migraciones de plataforma, el patrón strangler fig sigue siendo el enfoque más seguro: deriva una porción de la funcionalidad a la nueva implementación, verifícala en producción y amplía. La IA abarata la construcción de cada porción, lo que hace la migración incremental más atractiva que nunca.

Técnicas útiles:

  • Ejecución en paralelo. Ejecuta las rutas de código antigua y nueva para la misma petición, compara los resultados y devuelve el antiguo. Registra las diferencias e investígalas.
  • Feature flags por porción migrada, con vuelta atrás rápida.
  • Ensayos de migración de datos sobre copias de tamaño de producción antes del cambio definitivo.

En servicios Java, avanzar hacia un monolito modular suele ser un primer objetivo mejor que los microservicios, y los agentes son buenos haciendo respetar los límites entre módulos una vez definidos.

Ejemplo: actualizar de Java 8 a Java 25

Una secuencia típica que uso para actualizaciones de la JVM:

  1. Actualiza las herramientas de build (wrapper de Maven/Gradle, plugins) y consigue un build en verde con el JDK antiguo.
  2. Ejecuta las recetas de OpenRewrite para la versión de Java de destino y para Jakarta EE si pasas a Spring Boot 3.
  3. Cambia el JDK en CI y deja que el agente corrija los errores de compilación por lotes.
  4. Arregla los tests que fallan: a menudo reflexión, APIs eliminadas o comportamiento por defecto cambiado (por ejemplo, datos de locale o valores por defecto de TLS).
  5. Adopta funciones nuevas de forma selectiva: records para los DTO, pattern matching y, donde encaje, virtual threads.
  6. Haz pruebas de carga antes de producción; el comportamiento del GC y de la memoria cambia entre versiones.

Migraciones de plataforma: donde la IA ayuda menos de lo que esperas

Migrar sistemas de negocio —por ejemplo, de 1C a Odoo— consiste sobre todo en mapear datos, decidir procesos de negocio y formar a los usuarios. La IA ayuda a:

  • Extraer reglas de negocio del código y los informes antiguos a documentos legibles.
  • Generar scripts de mapeo de datos y consultas de validación.
  • Redactar módulos personalizados que sigan las convenciones de la plataforma de destino.

No sustituye los talleres con usuarios ni la decisión de qué personalizaciones abandonar.

Medir el progreso

  • Grado de avance de la migración por módulo o por número de usos de APIs obsoletas que quedan.
  • Tasa de fallos por cambio de los PRs de migración frente a los PRs habituales.
  • Diferencias de comportamiento encontradas en las ejecuciones en paralelo.
  • Horas de ingeniería por unidad: compara los primeros lotes con los posteriores; los pipelines bien ajustados se aceleran mucho.

Preguntas frecuentes

¿Podemos pedirle a un agente que reescriba toda la aplicación en un stack nuevo? Obtendrás código que parece completo y que se comporta de forma distinta en cientos de pequeños detalles. Las reescrituras necesitan descubrir el comportamiento y verificar de forma incremental; la IA acelera ambas cosas, pero no permite saltárselas.

¿Qué modelo deberíamos usar? Usa un modelo potente para el análisis y las transformaciones ambiguas, y plantéate uno más barato para los lotes mecánicos de gran volumen una vez probado el patrón. Consulta cómo elegir un LLM.

¿Qué hacemos con código que no tiene ningún test? Primero, tests de caracterización. Si ni siquiera eso es práctico, empieza con tests golden master a nivel de API y ejecuciones en paralelo.

¿El código generado es mantenible? Sigue los ejemplos que le das. Invierte en un buen documento de mapeo con ejemplos idiomáticos de antes y después, y la salida estará a la altura.

Fuentes

  1. Nikolov et al. (2025). How is Google using AI for internal code migrations?
  2. Airbnb Engineering (2025). Accelerating Large-Scale Test Migration with LLMs.
  3. AWS. Amazon Q Developer: transforming code.
  4. Documentación de OpenRewrite.
  5. Martin Fowler. Strangler Fig Application.
  6. Michael Feathers. Working Effectively with Legacy Code. Prentice Hall, 2004.