Reescribir código con IA: lo que enseña curl en Rust
Reescribir código con IA es pedir a un agente que convierta un programa existente a otro lenguaje (migrarlo o portarlo), o que lo rehaga desde cero, y comprobar el resultado con los tests del original. En noviembre de 2026, el creador de curl ha analizado uno de los ejemplos más llamativos: una reescritura de curl, la herramienta y librería de transferencias que, según su web, suma más de veinte mil millones de instalaciones, hecha con un agente de IA en algo más de tres semanas. Pasa 1992 de los 1996 tests de curl. En esas mismas semanas, curl fusionó más de 300 commits que la reescritura no tiene.
La tentación es leerlo como «la IA ya reescribe cualquier cosa». La lectura útil es otra: pasar los tests del original es necesario, pero no basta. Los tests miden lo que alguien decidió comprobar, no todo lo que el programa hace. Y una reescritura no termina el día que pasa la suite: empieza ahí. El mapa general de cómo trabajar con estas herramientas está en IA para programar. Y es la idea de la IA Limpia, el enfoque de esta web: la IA acelera lo que ya hay, y en este caso lo que había era una suite de tests excelente.
Qué ha pasado con curl
El 17 de noviembre de 2026, Daniel Stenberg, creador y mantenedor de curl, publicó en su blog «Actual curl rewrites in Rust». Habla de dos proyectos:
kov/curl, que su README presenta como una reescritura de curl y libcurl en Rust escrita por Claude, en Claude Code, «under the direction and review of this repository’s maintainer» (bajo la dirección y la revisión de su mantenedor, traducción nuestra). Empezó el 20 de octubre de 2026. El README no dice qué versión del modelo se usó.urlx, que se presenta como una reimplementación de curl desde cero en un lenguaje con seguridad de memoria y apareció unos meses antes. Ni su README ni Stenberg dicen cómo se escribió.
Las cifras, con lo que mide cada una:
| Dato | Cifra | Quién lo dice y qué mide |
|---|---|---|
| Tamaño | ~185.000 líneas de C → ~340.000 de Rust | Stenberg, según su propio recuento, sin detallar qué cuenta |
| Tamaño | ~200.000 líneas de C → ~430.000 de Rust | README de kov/curl: C de lib/ y src/; Rust con los tests incluidos |
| Tests | 1992 de 1996 en Linux | README de kov/curl, con la suite de curl (runtests) en su configuración de referencia, con OpenSSL; un fallo también lo tiene la versión en C. En Windows con Schannel, 1933 de 1948 |
| Tests | 1300 tests de curl | README de urlx: de los tests 1 a 1400, con 92 saltados y 25 excluidos. No es la suite completa, así que no se compara con la cifra de kov/curl |
| Coste | 8.600 USD | Lo que afirma kov/curl, según Stenberg, que enlaza a un artefacto de claude.ai; no está en su README ni verificado |
Stenberg dice no haber hablado con los autores de ninguno de los dos.
Por qué ha sido posible: los tests como contrato
Stenberg lo explica sin rodeos: curl está muy bien documentado, tiene cientos de aplicaciones de código abierto que usan su API y miles de casos de prueba para verificar la implementación. Con eso, el trabajo del agente se parece a traducir un libro con el original delante y un examen para cada página.
No es un caso aislado. En febrero de 2026, el navegador Ladybird portó parte de su motor de JavaScript de C++ a Rust con Claude Code y Codex (unas 25.000 líneas en unas dos semanas, según su autor) y exigió que las dos versiones produjeran exactamente la misma salida, con 0 regresiones en más de 65.000 tests. Su autor lo describe como un trabajo dirigido por personas, no como generación autónoma de código, y reconoce que el Rust resultante no es idiomático. Sin una red así, la traducción con modelos de lenguaje falla mucho: un estudio presentado en ICSE 2024 (Pan y otros), con modelos de 2023 y sin agentes ni suites grandes, midió entre un 2,1 % y un 47,3 % de traducciones correctas según el modelo.
Es la misma lección de los tests de caracterización: antes de que un agente toque código heredado, fija con tests lo que hace hoy. Curl llega a la reescritura con ese trabajo hecho desde hace décadas. La mayoría de los proyectos, no.
Lo que pasar los tests no te dice
Esta parte es interpretación nuestra sobre el caso, salvo donde se cita a Stenberg o a los README.
Lo que la suite no cubre
Una suite verde dice que el código nuevo hace lo mismo en los casos probados. Fuera de ellos, no dice nada. El propio README de kov/curl lo reconoce con honestidad: mantiene un fichero, DIVERGENCE.md, con las diferencias deliberadas respecto a la versión en C, y solo ha portado 74 de los 87 tests unitarios de C (los otros 13 prueban detalles internos de C sin equivalente).
Un ejemplo pequeño, en JavaScript, de cómo pasa. Una función que lleva años en producción da formato a precios en céntimos:
// precio.mjs: la original
export function formatearPrecio(centimos) {
const signo = centimos < 0 ? '-' : '';
const abs = Math.abs(centimos);
const euros = String(Math.floor(abs / 100))
.replace(/\B(?=(\d{3})+$)/g, '.');
const resto = String(abs % 100)
.padStart(2, '0');
return `${signo}${euros},${resto} €`;
}
Alguien la reescribe más corta, y pasa los tres tests que tenía:
// precio-reescrito.mjs: la nueva
export function formatearPrecio(centimos) {
const euros = (centimos / 100)
.toFixed(2)
.replace('.', ',');
return `${euros} €`;
}
// precio.test.mjs
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { formatearPrecio } from
'./precio-reescrito.mjs';
test('céntimos sueltos', () => {
assert.equal(
formatearPrecio(5), '0,05 €');
});
test('euros y céntimos', () => {
assert.equal(
formatearPrecio(1999), '19,99 €');
});
test('un reembolso', () => {
assert.equal(
formatearPrecio(-250), '-2,50 €');
});
Los tres pasan:
node --test precio.test.mjs
ℹ tests 3
ℹ pass 3
ℹ fail 0
Todo en verde. Pero nadie había escrito un test de mil euros o más, y la versión original separa los miles con un punto.
El test diferencial: comparar la versión vieja y la nueva
Un test diferencial ejecuta la versión vieja y la nueva con las mismas entradas, muchas, y comprueba que dan lo mismo. Es una forma de test de regresión pensada para reescrituras:
// comparar.test.mjs
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { formatearPrecio as original } from
'./precio.mjs';
import { formatearPrecio as nueva } from
'./precio-reescrito.mjs';
test('la nueva da lo mismo que la original',
() => {
const hasta = 500_000;
for (let c = 0; c <= hasta; c++) {
assert.equal(
nueva(c), original(c), `con ${c}`);
}
});
Al ejecutarlo:
node --test comparar.test.mjs
✖ la nueva da lo mismo que la original
AssertionError [ERR_ASSERTION]: con 100000
+ actual - expected
+ '1000,00 €'
- '1.000,00 €'
Pasa las primeras 100.000 entradas y falla justo en 100.000 céntimos: mil euros. El test diferencial no sabe qué es lo correcto: solo sabe que las dos versiones no hacen lo mismo, y eso es justo lo que quieres saber de una reescritura.
Ojo: que dos versiones no coincidan no dice cuál está mal. Si le pasas medio céntimo, la original arrastra un error que llevaba años ahí:
node -e "import('./precio.mjs').then(m => console.log(m.formatearPrecio(0.5)))"
0,0.5 €
La nueva devuelve 0,01 €. Cada diferencia te obliga a decidir: o respetas el comportamiento antiguo, o lo cambias a propósito y lo dejas escrito con un test. kov/curl lo hace así: cada diferencia deliberada respecto a la versión en C está en DIVERGENCE.md, con el test que la fija. Y aquí se pueden probar todas las cantidades; en la mayoría del código no, y entonces se generan entradas al azar (pruebas basadas en propiedades) o se reutilizan entradas reales. El README de kov/curl usa la versión en C como referencia: cuando las dos discrepaban en un caso de la suite, lo ejecutaba primero en C. Además, sembró fallos a propósito y usó pruebas de mutación (cargo-mutants), dos formas de medir si los tests detectan errores. Lo que el test diferencial añade es salir de los casos de la suite.
El original no se para
Stenberg aporta otro dato: en algo más de tres semanas, curl fusionó más de 300 commits, entre ellos algo más de 200 correcciones de errores y varias de vulnerabilidades. Ninguna está en las reescrituras. Una reescritura que sale de un original vivo empieza a quedarse atrás el mismo día, como un edificio copiado ladrillo a ladrillo mientras el de al lado sigue en obras.
También recuerda algo que ninguna suite puede comprobar el día de la entrega: décadas de estabilidad de API (la interfaz que usa el código que llama a libcurl) y de ABI (la interfaz binaria: los programas ya compilados pueden cambiar de versión de libcurl sin recompilar). kov/curl afirma que exporta todos los símbolos de libcurl y que los programas instalados que usan libcurl se enlazan contra ella. Eso es compatibilidad hoy; Stenberg habla de otra cosa: décadas sin romperla. Según él, solo curl puede presumir de eso; una alternativa tendría que demostrarlo con los años.
Cambiar de lenguaje no arregla todos los fallos
De las 81 vulnerabilidades confirmadas en curl en lo que va de 2026, Stenberg cuenta 14 (un 17,3 %) causadas por errores que un lenguaje con seguridad de memoria probablemente habría evitado. Su conclusión: una implementación en Rust seguiría teniendo las otras 67. Como lectura nuestra: son errores que no dependen del lenguaje, como fallos de lógica, y esos se traducen igual de bien que el código correcto.
Alguien tiene que entenderlo
Cientos de miles de líneas generadas son cientos de miles de líneas que alguien tendrá que leer cuando falle algo. El README de kov/curl dice que el trabajo se hizo bajo la dirección y la revisión de su mantenedor, pero no explica cómo se revisaron cientos de miles de líneas en un mes; a ese ritmo, la revisión tiene que apoyarse en los tests y en la comparación con C más que en leer cada línea (interpretación nuestra). En un equipo, la pregunta es quién la firma y cuántos más pueden hacerlo. Si solo lo entiende el agente, es deuda cognitiva: el código funciona, pero el porqué no está en la cabeza del equipo, y acaba siendo deuda técnica.
¿Reescribir o refactorizar con IA?
Stenberg no cree en las reescrituras, a ningún lenguaje. Prefiere pulir, iterar y refactorizar sin parar, y dice que escribir el código una vez nunca fue el problema: lo que hace fuerte a un proyecto es su ritmo de desarrollo, su equipo y su comunidad.
Sin necesidad de compartir esa postura entera, el caso deja una regla práctica. La IA ha abaratado mucho la primera parte de una reescritura, convertir el código; no ha abaratado la segunda, mantenerlo. Antes de aceptar una, pregunta quién la va a mantener y cómo va a absorber los cambios que siga recibiendo el original. Es la IA Limpia en un solo caso: la IA corre, pero el código que dura es el que alguien puede seguir manteniendo.
Cómo migrar o reescribir código con IA sin romperlo
Esto es criterio nuestro, no una receta de Stenberg ni de los proyectos citados:
- Caracteriza primero. Si el código no tiene tests, escríbelos contra la versión actual antes de que el agente toque nada (si nunca has escrito tests, empieza por qué es TDD). Sin ese contrato, «funciona igual» no significa nada.
- Compara salidas, no solo tests. Ejecuta la versión vieja y la nueva con las mismas entradas, muchas y variadas, y compara. Es lo que acabas de ver con los precios.
- Mide tus tests. Las pruebas de mutación dicen si tus tests detectan errores o solo pasan.
- Migra por partes. Sustituye el sistema pieza a pieza, con las dos versiones conviviendo, en lugar de cambiarlo todo de golpe. Martin Fowler lo llama Strangler Fig, por la higuera estranguladora, que germina sobre un árbol, echa raíces hasta el suelo y acaba sosteniéndose sola, aunque el árbol muera.
- Decide quién lo entiende. Si nadie del equipo puede explicar el código nuevo, no está terminado. Cómo revisarlo lo tienes en la checklist para revisar código generado por IA.
Límites
- Es un caso, y es excepcional. Curl tiene una suite, una documentación y un uso que casi ningún proyecto tiene. Que funcione con curl no dice que funcione con tu código heredado sin tests.
- Las cifras las dan los autores. Los resultados de tests salen de los README; el coste, de lo que afirma el autor de
kov/curlsegún Stenberg. Ninguna viene de una auditoría independiente. - Está pasando ahora. Los proyectos siguen recibiendo commits. Las cifras de este artículo son las publicadas a 20 de noviembre de 2026.
Tu siguiente paso
Elige una función de tu proyecto que alguien quiera «reescribir más limpia». Antes de tocarla, escribe un test diferencial como el de los precios: la versión actual frente a la nueva, con cientos de entradas. Si el agente propone la reescritura, que la pruebe contra eso, no solo contra los tests que ya había.
Si eres quien aprueba la reescritura, pide tres cosas antes de decir que sí: el test diferencial, el resultado de las pruebas de mutación y el nombre de quien la va a mantener.
Fuentes
Consultadas el 20 de noviembre de 2026.
- Daniel Stenberg, «Actual curl rewrites in Rust» (17 de noviembre de 2026): los dos proyectos, las líneas convertidas, los commits y correcciones de curl en esas semanas, las vulnerabilidades de 2026, la estabilidad de API y ABI y su opinión sobre reescribir.
- README de
kov/curl: autoría (Claude en Claude Code, dirigido y revisado por su mantenedor), fecha de inicio, líneas, resultados de la suite por plataforma,DIVERGENCE.md, tests unitarios portados y comprobaciones adicionales. - README de
urlx: reimplementación desde cero y tests de curl que pasa. - Martin Fowler, «Strangler Fig» (22 de agosto de 2024).
- curl.se: más de veinte mil millones de instalaciones.
- Andreas Kling, «Adopting Rust» (23 de febrero de 2026): el port de LibJS a Rust con Claude Code y Codex, la salida idéntica como criterio y las regresiones.
- Rangeet Pan y otros, «Lost in Translation: A Study of Bugs Introduced by Large Language Models while Translating Code», ICSE 2024: entre un 2,1 % y un 47,3 % de traducciones correctas y 15 tipos de errores.
Código: ejecutado el 20 de noviembre de 2026 con node --test en Node.js 24.21.0. Los tres tests de la versión reescrita pasan; el test diferencial falla al llegar a 100.000 céntimos y la original devuelve 0,0.5 € con medio céntimo, como se muestra (salidas recortadas).