Cómo Anthropic lleva a cabo migraciones de código a gran escala con Claude Code

Introducción

Cambiar el lenguaje principal de una base de código de producción madura solía ser el tipo de proyecto que los equipos posponían durante años. Este trabajo es costoso, riesgoso y difícil de estimar. Una migración podía consumir varios trimestres de ingeniería, durante los cuales las dos implementaciones se distanciaban cada vez más, logrando al final solo una consistencia de comportamiento incompleta.

Un proyecto interno reciente de Anthropic demuestra que esta situación está empezando a cambiar.

En julio de 2026, Anthropic publicó un informe práctico detallando cómo sus desarrolladores utilizaron Claude Code, Claude Fable 5, Claude Opus 4.8 y un flujo de trabajo multiagente dinámico para migrar diez paquetes de código en aproximadamente un mes. Estos paquetes variaban desde decenas de miles hasta cientos de miles de líneas de código.

Dos casos destacaron especialmente:

• Jarred Sumner, cofundador de Bun, usó Claude Code para migrar Bun de Zig a Rust, generando más de un millón de líneas de código en menos de dos semanas.
• Mike Krieger, codirector de Anthropic Labs, convirtió una base de código Python en aproximadamente 165,000 líneas de código TypeScript en un fin de semana.

La revelación importante no es que un modelo de IA pueda traducir archivos rápidamente, sino que un sistema de migración bien diseñado puede generar, revisar, probar, rechazar y regenerar código repetidamente con mínima intervención humana.

Anthropic resume su filosofía así: el trabajo principal del desarrollador no es corregir manualmente cada error generado, sino mejorar el proceso que produce esos errores.

Dos migraciones de código que cambiaron el cálculo de costos

Bun: Migración de más de un millón de líneas de Zig a Rust

Bun es un conjunto de herramientas integral para JavaScript y TypeScript que incluye un runtime, gestor de paquetes, bundler, ejecutor de pruebas y otras herramientas de desarrollo. Su implementación original dependía en gran medida de Zig e integraba una gran cantidad de código C y C++.

Jarred Sumner utilizó aproximadamente 50 flujos de trabajo dinámicos de Claude Code en 11 días para completar la migración a Rust. El pull request fusionado contenía más de un millón de líneas de código nuevo y miles de commits.

Antes de la fusión, el conjunto de pruebas de integración continua existente de Bun pasó en todas las plataformas compatibles. Anthropic informó posteriormente que aparecieron 19 regresiones después de la fusión, que fueron corregidas posteriormente.

Esta migración no fue un rediseño desde cero. El objetivo era mantener la arquitectura y el comportamiento existentes de Bun mientras se reemplazaba el lenguaje de implementación. Esto redujo las variables simultáneas: el proyecto podía centrarse en la semántica del lenguaje, la propiedad, la seguridad de memoria y la compatibilidad, en lugar de reconstruir el producto desde cero.

El informe oficial de Bun explica por qué Rust resultaba atractivo. Muchos problemas recurrentes de estabilidad involucraban gestión del ciclo de vida, rutas de limpieza omitidas, uso después de liberación, condiciones de carrera y riesgos de doble liberación. En Rust seguro, muchos de estos problemas se convierten en errores en tiempo de compilación, en lugar de descubrirse mediante fallos en producción, fuzzing o revisión manual.

Migración de Python a TypeScript en un fin de semana

El proyecto de Mike Krieger siguió un camino diferente. Esta migración no conservó la estructura de archivos original tanto como fue posible, sino que implicó un rediseño arquitectónico más amplio.

El resultado fue la generación de aproximadamente 165,000 líneas de código TypeScript en un fin de semana. Según se informa, el proceso utilizó:

• Cientos de agentes.
• Ocho etapas.
• Tres rondas de revisión adversarial.
• Un marco de pruebas de consistencia para comparar la salida de cada comando con la implementación en Python.

La razón de negocio era clara. Esta herramienta interna basada en Python se distribuía como un único binario, pero generarlo requería aproximadamente ocho minutos por plataforma, y unos 30 minutos para toda la matriz de lanzamiento.

Después de la migración, la compilación tomaba aproximadamente dos segundos, la velocidad de inicio mejoró seis veces y el equipo pudo eliminar una canalización de despliegue independiente.

Cuándo vale la pena considerar una migración de lenguaje

La migración de lenguajes aún requiere una razón genuina de ingeniería o negocio. Una generación de código más rápida no justifica cada reescritura.

Los equipos suelen reconsiderar la elección del lenguaje cuando el entorno ha cambiado desde la creación del sistema. Los desencadenantes típicos incluyen:

1. Compromisos conocidos se han convertido en problemas operativos recurrentes.
2. Lenguajes o ecosistemas más recientes ahora ofrecen mejor soporte de herramientas.
3. El ecosistema original se está reduciendo o es difícil contratar talento relacionado.
4. Los requisitos de seguridad o seguridad de memoria han cambiado.
5. El rendimiento de compilación, despliegue o ejecución se ha convertido en un cuello de botella.
6. Mantener la compatibilidad requiere soluciones alternativas cada vez más costosas.

La elección inicial de Zig para Bun tenía sentido: para un fundador que construía un runtime extremadamente amplio por su cuenta antes de la aparición de agentes de codificación contemporáneos, este lenguaje ofrecía control de bajo nivel que ayudó a Jarred Sumner a avanzar rápidamente.

Años después, Bun se ha convertido en una herramienta de producción ampliamente utilizada con una superficie de mantenimiento mucho mayor. El costo de los defectos recurrentes relacionados con la memoria aumentó, y Claude Code hizo que el trasplante mecánico fuera lo suficientemente viable como para probarlo.

Por lo tanto, la decisión no fue "Zig es malo y Rust es bueno", sino que la escala actual de Bun, las necesidades operativas y las herramientas disponibles han cambiado las compensaciones.

Migración más rápida, pero no gratuita

Las migraciones de lenguaje asistidas por IA aún pueden ser costosas.

Anthropic informa que el proyecto Bun consumió aproximadamente:

Categoría de uso	Cantidad reportada
Tokens de entrada no cacheados	5.9 mil millones
Tokens de salida	690 millones
Equivalente estimado de precio de API	Aproximadamente $165,000 USD

La parte principal de la migración de Python a TypeScript de Mike Krieger utilizó aproximadamente 27 millones de tokens.

Estas cifras son muy inferiores al costo de ingeniería de las migraciones tradicionales de varios años, pero no son insignificantes. Los equipos también deben considerar:

• Supervisión humana.
• Gastos de cómputo y API.
• Infraestructura de pruebas.
• Capacidad de CI.
• Máquinas de compilación.
• Revisión y corrección posteriores a la fusión.
• Costo de oportunidad durante la migración.
• Mantenimiento a largo plazo de la implementación en el lenguaje de destino.

La reducción de costos hace que más proyectos sean financieramente viables, pero no elimina la necesidad de un caso de negocio.

Por qué las migraciones grandes son tan adecuadas para los agentes de IA

Las migraciones grandes de lenguajes tienen múltiples características que las hacen especialmente adecuadas para trabajar con agentes de codificación colaborativos.

El trabajo es paralelizable

Las migraciones suelen involucrar cientos o miles de archivos, módulos, paquetes o bibliotecas que, una vez entendidas sus dependencias, pueden procesarse de forma independiente.

Los agentes pueden traducir unidades independientes en paralelo, en lugar de esperar un único flujo de implementación central. El desafío pasa de la velocidad de escritura a la orquestación, consistencia y verificación.

El código antiguo es una especificación detallada

Muchas tareas de software comienzan con requisitos incompletos. Las migraciones de lenguaje tienen un punto de partida mucho más sólido: la implementación original.

El código fuente existente define flujos de control, estructuras de datos, casos límite, comportamiento de errores, API públicas y manejo específico de plataforma. Cuando las reglas de migración no son claras, los agentes pueden consultar la referencia original en cualquier momento.

Las pruebas proporcionan un árbitro objetivo

Los agentes funcionan mejor cuando el éxito o fracaso se puede verificar mecánicamente.

Los compiladores, conjuntos de pruebas, scripts de consistencia, benchmarks o comparaciones deterministas de salidas proporcionan una única fuente de verdad para el flujo de trabajo. El sistema no necesita preguntar a un revisor si la nueva implementación "se ve correcta"; compara repetidamente el comportamiento con la implementación original para verificar consistencia.

El fracaso se convierte automáticamente en tareas pendientes

Los errores de compilador, fallos, fallos de pruebas y diferencias de salida describen naturalmente el trabajo restante.

El sistema de migración no necesita que los humanos creen tickets uno por uno.

Cada elemento de verificación fallido se puede clasificar y asignar a un agente de corrección.

Los errores repetidos se pueden corregir en origen

Cuando el mismo problema aparece en varios archivos, repararlos manualmente uno por uno no es la forma correcta de abordarlo.

Una mejor solución es actualizar la regla de migración que causa el error y luego regenerar únicamente las unidades afectadas. Esto convierte un defecto encontrado en una mejora permanente del proceso.

Requisito previo: Construir un juez confiable

Antes de traducir el código de producción, es necesario crear un sistema de verificación que pueda evaluar la implementación nueva y la antigua en igualdad de condiciones.

Sin un juez confiable, el proyecto no tiene una definición creíble de finalización.

Los conjuntos de pruebas escritos en el lenguaje fuente pueden depender de funciones privadas, clases internas o detalles de implementación que no existen en el lenguaje destino. Estas pruebas no siempre se pueden migrar directamente.

Anthropic sugiere preparar el sistema de juez en tres fases.

1. Clasificar las pruebas existentes

Distinguir las pruebas que expresan comportamiento externo de aquellas que dependen de detalles de implementación internos.

Las pruebas externas suelen involucrar comportamiento de línea de comandos, API públicas, archivos, red, salida observable o escenarios completos de aplicación. Estos contenidos son más portables entre diferentes lenguajes.

2. Reescribir pruebas para portabilidad

Convertir las pruebas orientadas al comportamiento en aserciones que puedan ejecutarse en ambas versiones.

Utilizar revisores adversariales independientes para asegurar que las pruebas reescritas no sean más débiles que la versión original. Las pruebas que son más fáciles de pasar pueden ocultar problemas de compatibilidad.

3. Validar el propio sistema de juicio

Ejecutar el sistema de juicio en la implementación original y confirmar que pasa.

Luego, romper intencionalmente el programa y confirmar que el sistema de juicio falla. Si un sistema de verificación no puede detectar defectos conocidos, no está preparado para supervisar la migración.

Mike Krieger no comenzó desde cero para construir un conjunto de pruebas completamente portátil. Su equipo creó un marco de pruebas de consistencia que cubría siete escenarios reales y consideraba cualquier diferencia entre Python y TypeScript como un defecto.

Flujo de migración de código de seis pasos con Claude

Primer paso: Crear el libro de reglas, el mapa de dependencias y el inventario de brechas

El primer paso sienta las bases que utilizarán todos los agentes posteriores.

Primero, construir el libro de reglas

El libro de reglas describe cómo se debe mapear el lenguaje fuente al lenguaje destino.

Su forma depende de la estrategia de migración.

Para migraciones que preservan la estructura, el libro de reglas puede incluir:

• Mapeo de tipos.
• Mapeo de manejo de errores.
• Reglas de propiedad.
• Convenciones de nomenclatura.
• Alternativas de biblioteca estándar.
• Patrones de interfaz de funciones externas.
• Reglas de operaciones asíncronas.
• Instrucciones para construcciones no soportadas.

Para rediseños, el libro de reglas se parece más a un documento de arquitectura. Define los límites de nuevos componentes, interfaces, contratos de datos y decisiones de diseño que los agentes de implementación deben seguir.

El orden es importante. El libro de reglas debe escribirse antes que el inventario de brechas, porque el inventario de brechas registra todo lo que las reglas predeterminadas no pueden manejar de manera segura.

Mapear dependencias

El trabajo en paralelo solo es seguro cuando el flujo de trabajo comprende qué unidades dependen entre sí.

El mapa de dependencias ayuda a determinar:

• Qué módulos deben migrarse primero.
• Qué archivos pertenecen al mismo lote.
• Qué interfaces deben estabilizarse antes de que comience el trabajo downstream.
• Qué bucles necesitan un tratamiento especial.
• Qué agentes paralelos podrían generar conflictos.

Algunos lenguajes exponen información de dependencias a través de manifiestos de paquetes o metadatos de módulos. Los sistemas más antiguos en C, C++ y Python pueden requerir scripts de análisis deterministas para descubrir el gráfico de dependencias.

Claude Code puede ayudar a crear y ejecutar ese script, pero el gráfico generado debe obtenerse por medios mecánicos, no solo adivinando a partir de la salida del modelo.

Registrar brechas de lenguaje y arquitectura

El inventario de brechas captura las diferencias que no se pueden manejar mediante traducción directa.

Para una migración de Zig a Rust, las brechas importantes incluyen la propiedad y el ciclo de vida de la memoria. Zig permite que algunas responsabilidades de limpieza se comuniquen mediante convenciones o anotaciones, mientras que Rust requiere que las restricciones de propiedad se expresen en el sistema de tipos.

Para un trabajo de migración de Python a TypeScript, la definición de interfaces es una brecha importante. Python a menudo acepta objetos basándose en el comportamiento en tiempo de ejecución, mientras que TypeScript requiere contratos explícitos antes de que el código se compile de manera segura.

El inventario debe considerarse un artefacto que se actualiza dinámicamente. Durante el proceso de traducción, compilación y pruebas de consistencia, surgen continuamente nuevas brechas.

Segundo paso: Poner a prueba las reglas con una mini migración desechable

No apliques el nuevo libro de reglas de inmediato a miles de archivos.

Primero, realiza una migración pequeña y luego descarta deliberadamente los resultados.

Para Bun, la prueba involucró una pequeña cantidad de archivos:

1. Un agente traduce el archivo según el libro de reglas.
2. Otro agente traduce un archivo comparable como lo haría un ingeniero experimentado en Rust.
3. Un tercer agente compara los resultados y propone reglas más sólidas.
4. Un revisor adversarial busca problemas de comportamiento o estructura.

Antes de aplicarlo realmente a los 1,448 archivos de Zig, este trabajo expuso dos problemas graves.

Las migraciones que mantienen la estructura sin cambios hacen que esta comparación sea relativamente fácil, ya que las dos implementaciones del mismo archivo se pueden revisar en paralelo.

Para rediseños, las pruebas de estrés deben orientarse al documento de arquitectura. Los agentes adversariales pueden atacar sus suposiciones, y luego se realiza una ejecución de extremo a extremo desechable para exponer interfaces faltantes y órdenes poco realistas.

El objetivo es mejorar el libro de reglas, no acumular código de producción. Una vez que se capturan las debilidades, se descartan los archivos generados.

Tercer paso: Traducir toda la base de código

Una vez que las reglas han superado las pruebas de estrés, el trabajo de traducción puede expandirse a todo el repositorio.

com/cms-assets/image/2026/07/26354d74-9a83-4821-b425-a17b95bb4e0e-677c6dd7-8531-47f9-93ce-bf7d7df38679.jpeg)

Anthropic describe un ciclo repetitivo que involucra tres roles:

1. El Implementador genera el código traducido.
2. El Revisor Adversario busca defectos y violaciones de reglas.
3. El Reparador aplica las correcciones aceptadas tras la revisión.

La implementación a menudo puede realizarse con modelos más pequeños y económicos. Los modelos más potentes deben reservarse para los revisores, los redactores de reglas, las decisiones arquitectónicas y las disputas que requieren un juicio más amplio.

Mantener la cola de forma mecánica

Los scripts por lotes deben determinar qué está completo revisando el sistema de archivos u otro estado determinista.

Por ejemplo, un archivo fuente puede considerarse traducido cuando su archivo destino correspondiente existe en el directorio esperado y ha pasado las puertas de revisión requeridas.

Reconstruir la cola desde el disco hace que el proceso sea reanudable. Si un agente se detiene, la máquina se reinicia o un lote falla, el orquestador puede reconstruir el trabajo restante sin depender de la memoria volátil de la conversación.

Marcar explícitamente el trabajo incierto

Cuando el agente implementador no pueda completar una traducción con confianza, debe dejar una marca buscable, como por ejemplo:

TODO(port): Explicar por qué esta parte necesita manejo manual o procesamiento posterior

La forma específica de la marca puede variar, pero debe incluir el motivo. Esto crea una cola estructurada para las fases de compilación y reparación.

Usar contextos de revisión independientes

El agente implementador no debe revisarse a sí mismo.

Anthropic y Bun emplearon una revisión adversaria en ventanas de contexto independientes. El revisor recibe el código modificado y se le indica que asuma que la implementación contiene defectos.

Dos revisores pueden examinar el mismo lote de forma independiente. Si sus conclusiones entran en conflicto, un tercer agente puede resolver la disputa.

Esta separación reduce la tendencia del agente de escritura a defender sus propias elecciones y hace que la ejecución autónoma prolongada sea más fiable.

Corregir el generador, no cada salida

Cuando un revisor encuentra el mismo defecto repetidamente, se debe actualizar el manual de reglas y regenerar los lotes afectados.

Parchear manualmente cientos de archivos generados genera inconsistencias y permite que el modo de fallo original persista. Corregir las reglas de generación evita que el problema se reproduzca en lotes posteriores.

Pasos 4, 5 y 6: Compilar, ejecutar y comparar comportamiento

Las tres últimas fases comparten el mismo ciclo básico: generar fallos objetivos, clasificar, asignar un reparador, revisar la reparación y repetir.

Paso 4: Compilar

La compilación convierte los errores a nivel de lenguaje en una cola determinista.

Que la compilación forme parte de cada ciclo de traducción depende del costo.

El compilador de TypeScript de Mike Krieger puede revisar una unidad en segundos, por lo que se ejecuta con frecuencia durante la implementación. La compilación de Rust de Bun toma más tiempo, por lo que Jarred Sumner mantiene Cargo fuera del bucle de traducción a nivel de archivo y compila lotes más grandes por separado.

Para compilaciones costosas, use un orquestador único o un daemon de compilación. El agente reparador escribe parches y solo permite que el daemon reconstruya. Esto evita que decenas de agentes inicien la misma operación costosa simultáneamente.

Los fallos del compilador a nivel de sistema merecen atención especial. Miles de errores similares pueden indicar una regla de dependencia faltante, una política incorrecta de límites de módulos o un mapeo de lenguajes problemático, no miles de fallos no relacionados.

Paso 5: Ejecutar pruebas de humo

Una vez que el código compila, ejecute las pruebas mínimas que revelen fallos graves y errores de tiempo de ejecución.

Los resultados de las pruebas de humo proporcionan otra fuente de verdad mecánica. Agrupe los fallos por causa raíz, en lugar de asignar un agente a cada mensaje de error sin análisis.

Las categorías útiles pueden incluir:

• Fallos de inicialización
• Recursos faltantes
• Errores de manejo de rutas
• Diferencias de serialización
• Defectos en el ciclo de vida de la memoria
• Comportamiento específico de la plataforma
• Suposiciones incorrectas sobre concurrencia
• Problemas de interfaz de funciones externas

Los revisores adversarios deben examinar las soluciones de causa raíz propuestas, especialmente cuando un solo cambio afecta a múltiples archivos.

Paso 6: Comparar el comportamiento original

La última fase consiste en comparar el nuevo programa con el original.

Ejecute un conjunto de pruebas portátil o un marco de verificación de equivalencia en ambas implementaciones. Cualquier diferencia inexplicable debe considerarse un defecto de migración, a menos que el equipo la acepte intencionalmente como un cambio de producto.

El agente reparador puede examinar:

• Casos de prueba fallidos
• La implementación original
• La implementación traducida
• Las reglas de migración que afectan al código
• Casos de fallo anteriores relacionados

Para procesos de reconstrucción largos, use un daemon de compilación que procese parches en lotes, compile de una vez, solo vuelva a ejecutar las pruebas afectadas y devuelva los resultados a la cola.

Cuando el mismo patrón de fallo aparece en múltiples pruebas, las medidas correctivas deben trasladarse hacia arriba. Actualice el manual de reglas y regenere los archivos bajo la regla errónea.

Alternativas cuando no hay un conjunto de pruebas portátil

La falta de un conjunto de pruebas no impide la migración.

Puede utilizar la aplicación original como implementación de referencia y construir un marco de verificación de equivalencia de comportamiento en torno a escenarios de usuario reales.

El flujo de trabajo de Mike Krieger ejecutaba siete escenarios tanto en la versión de Python como en la de TypeScript, comparaba los resultados y asignaba cada fallo a un bucle de reparación dedicado. Posteriormente, Claude diseñó pruebas integrales adicionales que se ejecutaron durante cuatro noches consecutivas.

Incluso si el equipo necesita construir un nuevo mecanismo de arbitraje alrededor del código original, el código original sigue siendo el único punto de referencia.

Lecciones prácticas aplicables a través de proyectos

Anthropic advierte que no se debe tomar su flujo de trabajo como una plantilla universal. Cada código fuente tiene diferentes costos de compilación, semántica de lenguaje, calidad de pruebas, restricciones de plataforma y compensaciones aceptables.

Sin embargo, las siguientes prácticas se mantienen consistentes en múltiples proyectos.

Enfocarse en patrones, no en fallos individuales

Los fallos individuales pertenecen al ámbito del bucle de reparación.

El esfuerzo humano debe centrarse en los defectos recurrentes, las reglas faltantes, los límites de tareas poco razonables, los enlaces de verificación débiles y los cuellos de botella en el sistema de orquestación.

Adoptar la revisión adversaria

El revisor debe intentar activamente demostrar que el código tiene errores.

Esto no implica ser vago o pesimista. Las conclusiones de la revisión deben señalar defectos específicos, reglas violadas, suposiciones incorrectas o discrepancias de comportamiento.

Automatizar la verificación

Los compiladores, los casos de prueba, los scripts deterministas, los puntos de referencia y las diferencias de salida deben convertirse en criterios de aceptación de resultados.

Las opiniones de los modelos son valiosas para la investigación y la revisión, pero no deben reemplazar la verificación objetiva, siempre que esta sea posible.

Evitar usar el modelo más potente en todas partes

El trabajo de traducción a gran escala suele ser repetitivo y puede ser manejado por modelos más pequeños.

Los modelos más potentes deben usarse para:

• Redactar reglas
• Revisar la arquitectura
• Descubrir defectos sistémicos
• Resolver disputas de revisión
• Diseñar planes de verificación
• Manejar casos límite difíciles

Esto reduce el costo de tokens sin eliminar el razonamiento fuerte de las decisiones de mayor riesgo.

Invertir trabajo humano por adelantado

El manual de reglas, el grafo de dependencias, la estrategia de verificación y las pruebas de estrés requieren la participación humana más cuidadosa.

Una vez que estos fundamentos son sólidos, el resto del trabajo masivo se convierte en un proceso de cola. Una base débil hace que cada etapa posterior sea más costosa.

Asegurar que el flujo de trabajo sea interrumpible y reanudable

El proceso de migración debe poder recuperarse de una interrupción sin necesidad de reconstruir el estado a través del historial de chat.

Almacene el progreso en archivos, commits, listas, bases de datos u otros artefactos deterministas. "Completado" debe tener un significado legible por máquina.

Separar las operaciones compartidas costosas

La compilación, las pruebas de integración, la creación de paquetes y los puntos de referencia completos pueden convertirse en cuellos de botella.

Ejecute estas operaciones a través de un servicio o daemon controlado para que los agentes paralelos no desperdicien recursos ni corrompan el estado compartido.

Resultados de la migración a Rust de Bun

La versión en Rust de Bun ya está en producción, aunque los resultados aún presentan compensaciones de ingeniería.

Anthropic informa que aproximadamente el 4% del código Rust permanece en bloques unsafe, principalmente operaciones cortas con punteros en los límites con C y C++. Rust no eliminó todos los problemas de bajo nivel, pero los limitó más a áreas explícitas.

Las mejoras reportadas incluyen:

Medida	Resultado

| Uso de memoria en 2000 reconstrucciones | De 6745 MB a 609 MB |
| Tamaño del binario en Linux y Windows | Reducción del 19 % |
| Rendimiento en cargas de trabajo reales seleccionadas | Mejora del 2 %–5 % |
| Fugas de memoria detectables | Corregidas |
| Regresiones reportadas por Anthropic tras la fusión | 19, posteriormente corregidas |

Estos resultados importan más que el número bruto de líneas de código. Una migración exitosa no se mide por la velocidad con la que un agente genera código, sino por la compatibilidad, mantenibilidad, mejoras en ejecución y la capacidad de seguir desarrollando el producto después.

Aspectos a evaluar antes de iniciar el equipo

Antes de iniciar una migración masiva asistida por IA, responda las siguientes preguntas.

¿La implementación fuente es un punto de referencia estable?

Si el sistema original cambia rápidamente, será difícil medir la consistencia. Considere congelar interfaces seleccionadas o priorizar la migración de módulos estables.

¿Se puede medir el éxito de forma mecánica?

Defina las comprobaciones del compilador, pruebas, escenarios, puntos de referencia y comparaciones de salida que determinen la finalización.

Objetivos vagos como "que se comporte igual" no son suficientes.

¿La migración conserva la estructura o rediseña?

La migración directa facilita la comparación y la paralelización. El rediseño puede generar una arquitectura superior, pero introduce más juicios y requiere revisiones de diseño más estrictas.

¿Cuál es el paso más costoso?

Evalúe los siguientes costos:

• Llamadas al modelo
• Compilación
• Ejecución de pruebas
• Concurrencia en CI
• Almacenamiento del repositorio
• Ejecución de integración completa
• Revisión humana

Diseñe el orquestador en torno al recurso compartido más costoso.

¿Qué operaciones requieren aprobación humana?

Defina los siguientes límites:

• Comandos destructivos de Git
• Cambios de dependencias
• Cambios arquitectónicos
• Código sensible a la seguridad
• Credenciales de producción
• Operaciones de publicación
• Cambios en la API pública

En el flujo de trabajo de Bun, los agentes interferían entre sí mediante comandos como git stash y git reset. Se actualizaron las reglas de orquestación para prohibir operaciones inseguras en el repositorio compartido y restringir a los agentes a confirmaciones controladas a nivel de archivo.

¿Cuál es la estrategia de reversión?

Las migraciones deben mantenerse descartables hasta que haya evidencia que respalde su fusión.

Use ramas aisladas, compilaciones reproducibles, puntos de control y un proceso claro para abandonar o regenerar el trabajo cuando las reglas fallen.

Preguntas frecuentes

¿Qué es la migración de código asistida por IA?

La migración de código asistida por IA utiliza agentes de codificación que, bajo un flujo de trabajo controlado, realizan la traducción, revisión, compilación, prueba y reparación del código base. El modelo no reemplaza la validación; el compilador, las pruebas, las comprobaciones de consistencia y las reglas definidas por humanos siguen siendo la autoridad.

¿Claude Code realmente reescribió Bun de Zig a Rust?

Jarred Sumner completó la migración a Rust utilizando el flujo de trabajo dinámico de Claude Code. La solicitud de extracción de GitHub correspondiente se fusionó en mayo de 2026. La cuenta oficial de Bun indicó que el trabajo tomó aproximadamente 11 días, basándose en implementaciones en paralelo, revisión adversarial y el conjunto de pruebas independiente del lenguaje del proyecto.

¿Cuántas líneas de código implicó la migración de Bun?

La solicitud de extracción fusionada mostró más de un millón de líneas de código nuevas, junto con código eliminado y modificado. El número de líneas por sí solo no mide la calidad, por lo que los indicadores más importantes son los resultados de compilación, pruebas multiplataforma, rendimiento, uso de memoria, tamaño del binario y el manejo de regresiones posteriores a la fusión.

¿Cuál fue el costo de la migración de Bun con IA?

Según 5900 millones de tokens de entrada no almacenados en caché y 690 millones de tokens de salida, Anthropic estimó un costo de API de aproximadamente 165 000 USD. El costo real de la organización puede variar según acuerdos de precios, infraestructura interna, horas de personal, uso de CI y reparaciones posteriores a la fusión.

¿Qué es un manual de reglas de migración?

Un manual de reglas de migración es un conjunto de políticas legibles por máquina o por agentes que describe cómo se asignan los patrones del lenguaje fuente a la implementación objetivo. Abarca tipos, propiedad, errores, interfaces, nomenclatura, casos no soportados, decisiones arquitectónicas y otras reglas que los agentes de implementación deben seguir de manera consistente.

¿Por qué usar un revisor adversarial?

Los agentes de implementación tienen contexto e inercia que pueden inclinarlos a aceptar sus propias soluciones. El revisor adversarial trabaja en un contexto independiente y se le indica que busque defectos, violaciones de reglas y diferencias de comportamiento, en lugar de ayudar a fusionar el código.

¿Este método funciona sin un conjunto de pruebas existente?

Es posible, pero el equipo debe establecer otro árbitro objetivo. Una plataforma de pruebas de consistencia puede ejecutar escenarios reales en ambas implementaciones y comparar salidas, mientras que nuevas pruebas de extremo a extremo pueden exponer fallos que las comprobaciones de traducción estática pasan por alto.

¿Todos los códigos heredados son adecuados para la migración con IA ahora?

No. La migración aún requiere beneficios medibles, una implementación de referencia estable, validación objetiva, presupuesto suficiente y un plan de reversión aceptable. Los sistemas con pruebas débiles, comportamiento no documentado, requisitos cambiantes o restricciones de seguridad críticas pueden necesitar una preparación significativa o ser inviables con las capacidades actuales de IA.

Preparación necesaria antes de que los agentes puedan ayudar de manera responsable.

Herramientas relacionadas

• Claude Code: Herramienta de codificación con agentes de Anthropic para comprender repositorios, editar archivos, ejecutar comandos y coordinar el desarrollo.
• Kit de migración de código de Anthropic: Prompts, plantillas y scripts oficiales para construir flujos de trabajo de migración de lenguajes.
• Plugin de modernización de Claude Code: Plugin oficial enfocado en actualizaciones de frameworks y modernización de sistemas heredados (no en migraciones completas de lenguaje).
• Bun: Conjunto de herramientas para JavaScript y TypeScript utilizado en el caso de estudio de migración de un millón de líneas de código de Zig a Rust de Anthropic.
• Rust: Lenguaje de programación de sistemas con seguridad de memoria elegido para la nueva implementación de Bun.
• Zig: Lenguaje de programación de sistemas que Bun usaba antes de migrar a Rust.
• TypeScript: Lenguaje JavaScript con tipos utilizado en el ejemplo de migración de Python de Anthropic.

Enlaces relacionados

• Guía de migración de código a gran escala de Anthropic: Metodología oficial de seis pasos y dos casos de estudio de migración de Anthropic.
• Reescritura de Bun a Rust: Explicación técnica detallada de Jarred Sumner sobre la motivación, el ciclo de orquestación, el proceso de revisión y los resultados de la migración.
• Solicitud de extracción de la reescritura de Bun a Rust: Solicitud de extracción pública fusionada que contiene la migración masiva a Rust.
• Kit de migración de código para usar con Claude Code: Kit de inicio general derivado del proceso de migración.
• Introducción a los flujos de trabajo dinámicos: Explicación de Anthropic sobre los flujos de trabajo adaptativos multiagente de larga duración en Claude Code.
• Documentación de Claude Code: Documentación oficial de instalación, flujos de trabajo, configuración y uso.
• Mejores prácticas de Claude Code: Guía práctica sobre contexto del repositorio, sesiones en paralelo, validación y flujos de trabajo con agentes.

Resumen

Las prácticas recientes de migración de Anthropic demuestran que los proyectos de portabilidad lingüística pueden reorganizarse en torno a flujos de trabajo de agentes, en lugar de depender de una única reescritura manual prolongada. La migración de Bun de Zig a Rust y el proyecto de Anthropic de Python a TypeScript se basan en implementación paralela, revisión adversarial, verificación determinista y regeneración iterativa.

La parte reutilizable es el proceso: construir evaluadores, definir reglas, mapear dependencias, someter los métodos a pruebas de estrés, traducir en lotes recuperables, compilar, ejecutar y comparar comportamientos. Cuando un mismo defecto aparece repetidamente, se corrige la regla o el flujo de trabajo que lo genera, en lugar de reparar manualmente cada salida.

Este enfoque aún requiere un presupuesto considerable, pruebas sólidas, permisos controlados y juicio humano a nivel arquitectónico. Reduce los costos de migración, pero no elimina el trabajo de ingeniería.

Responsabilidad.

El punto clave es simple: una migración confiable de IA surge de ciclos de producción verificables, no de una sola instrucción que haga que el modelo reescriba toda la base de código.