# sumner-bun-rewrite-rust-claude-2026-07-08

## Veille

Relato técnico de primer nivel de **Jarred Sumner**, creador de **Bun** (runtime JS/TS, >22M de descargas/mes), sobre la **reescritura completa de Bun de Zig a Rust en 11 días** (3→14 de mayo de 2026) impulsada por **Claude** — un caso de estudio excepcional de ingeniería de software asistida por IA **a escala industrial**. Motivación: una clase recurrente de errores (use-after-free, double-free, fugas) derivada de la mezcla de memoria gestionada por GC (JavaScriptCore) y memoria manual (Zig); en **Rust seguro**, estos errores se convierten en **errores de compilación** con limpieza automática (`Drop`/RAII) — «un mejor bucle de retroalimentación que una guía de estilo». Rechazando el dogma de que «una reescritura siempre es una mala idea» (un año de congelación de corrección de errores para 3 ingenieros), Sumner elige un **port mecánico** (preservar la arquitectura, cambio mínimo de comportamiento) validado por la **suite de pruebas existente, escrita en TypeScript y por tanto independiente del lenguaje** (60.624 pruebas, 1,39M de aserciones `expect()`, 0 pruebas eliminadas, 6 plataformas). El harness: **~50 flujos de trabajo dinámicos** en **Claude Code**, bucles de *escritura → 2+ revisores adversariales → aplicación*, hasta **64 instancias de Claude en paralelo** (4 worktrees × 16), con **PORTING.md** + **LIFETIMES.tsv** generados en preparación. Cifras: **6.502 commits** (pico de 695/h, 58/min, ~1.300 líneas/min), diff final **+1.009.272 líneas**, ~16.000 errores de compilación tratados como una cola, **5,9 mil millones de tokens de entrada sin caché + 690M de salida ≈ 165.000 $**. Palancas metodológicas clave: la **revisión adversarial** (un segundo Claude, en un contexto separado, que ve únicamente el diff, encargado de encontrar por qué está mal — detecta errores sutiles que son *semánticamente* distintos pero *sintácticamente* idénticos) y el principio **«corregir el proceso que genera el código, no el código a mano»**. Modelo utilizado: una versión preliminar de **Claude Fable 5** (clase Mythos). Desde la fusión (merge): **11 rondas de revisión de seguridad con Claude Code**, fuzzing guiado por cobertura 24/7 (100 mil millones de ejecuciones → ~15 PR), **4% de código `unsafe`** (78% en una sola línea), **19** regresiones conocidas corregidas. En producción: Claude Code v2.1.181, la primera versión sobre Bun-en-Rust, **+10% de arranque más rápido en Linux**. Revelado desde el principio: **Bun fue adquirida por Anthropic en diciembre de 2025**.

## Titre Article

Rewriting Bun in Rust

## Date

2026-07-08

## URL

https://bun.com/blog/bun-in-rust

## Keywords

Bun, Jarred Sumner, reescritura de Zig a Rust, port mecánico, runtime JavaScript TypeScript, esbuild, adquisición por Anthropic, Claude Fable 5, clase Mythos, Claude Code, flujos de trabajo dinámicos, ingeniería de harness, 64 instancias de Claude en paralelo, git worktrees, revisión adversarial, revisión adversarial, ventanas de contexto separadas, 1 implementador 2 revisores 1 corrector, bucle escritura-revisión-aplicación, corregir el proceso no el código, PORTING.md, LIFETIMES.tsv, Rust seguro, Drop, RAII, use-after-free, double-free, fuga de memoria, recolector de basura, JavaScriptCore, gestión manual de memoria, defer errdefer, guía de estilo, TigerStyle, punteros inteligentes, ~100 crates, dependencias cíclicas, 16000 errores de compilación, cola de errores, smoke tests, systemd-run cgroups, aislamiento, suite de pruebas en TypeScript independiente del lenguaje, 60624 pruebas, 1, 39M de aserciones expect, 0 pruebas eliminadas, 6 plataformas, Buildkite CI, 6502 commits, 1009272 líneas, 5, 9 mil millones de tokens de entrada, 690M de tokens de salida, 165000 dólares, 11 días, ReleaseSafe, Address Sanitizer, ASAN, Fuzzilli, fuzzing guiado por cobertura, 100 mil millones de ejecuciones, 11 rondas de revisión de seguridad, código unsafe 4%, 19 regresiones, macro debug_assert, semánticamente distinto sintácticamente idéntico, Claude Code v2.1.181, 10% de arranque más rápido, LTO entre lenguajes, binario 20% más pequeño, un ingeniero puede hacer mucho más, cementerio de proyectos paralelos muertos

## Authors

Jarred Sumner (créateur de Bun ; travaille chez Anthropic depuis le rachat de Bun en décembre 2025)

## Ton

**Perfil**: publicación técnica en primera persona (blog oficial de Bun), de formato extenso (~5000 palabras), dirigida a ingenieros de sistemas/runtime y a la comunidad de ingeniería de software asistida por IA. **Revelación por adelantado** («Bun fue adquirida por Anthropic en diciembre de 2025; usé una versión preliminar de Claude Fable 5»), que neutraliza el conflicto de interés sin ocultarlo. Tecnicidad muy alta (lifetimes, `Drop` frente a `defer`, dependencias cíclicas entre crates, timespec negativo, `unwrap_or` eager frente a `unwrap_or_else` lazy) pero pedagógica: cada decisión está motivada por el razonamiento «¿cómo lo haría un humano?».

**Estilo**: honestidad metodológica declarada — el autor relata sus **falsos inicios** (Claude haciendo `git stash`/`reset` y colisionando entre instancias; Claude «stubbing» funciones en lugar de corregirlas; timeouts de depuración; disco saturado por IOPS insuficientes) tanto como sus éxitos. Rechazo explícito del prompt mágico («Reescribe Bun en Rust. No cometas ningún error.» *no* es lo que hizo). Reconocimiento sincero de la herramienta que deja atrás («Zig hizo posible Bun… siempre le estaré agradecido»). Citas textuales destacadas: *«El resultado por defecto para proyectos de alcance tan ambicioso como Bun es unirse al cementerio de los proyectos paralelos muertos»*, *«Un ingeniero puede hacer mucho más hoy que hace un año»*, *«Si necesitas un comentario de un párrafo entero para justificar por qué el workaround está bien, el código está mal — corrige el código»*, *«Esto es la vanguardia de lo que es posible hoy en día»*. Rico en visualizaciones de datos (commits por hora, la carrera hacia el verde por plataforma, una repetición de los 11 días). Documentado con cifras reales de commits (atribución de la revisión en el asunto del commit).

## Pense-betes

- **Idea clave: las reescrituras de lenguaje ya no son una decisión sin retorno.** Históricamente, cambiar el lenguaje de un proyecto como Bun (535.496 líneas de Zig) = ~1 año para un equipo pequeño, con **una congelación de correcciones de errores, seguridad y funcionalidades** — por tanto poco realista, por tanto «nunca se hace». La IA agéntica transforma esta disyuntiva: *«¿Y si dedico una semana a probar si el nuevo modelo de Anthropic puede reescribir Bun en Rust?»* Resultado: **11 días**.
- **El argumento del «por qué Rust» trata de bucles de retroalimentación, no de gustos.** La clase de error dominante (use-after-free, double-free, llamadas a `free` omitidas en las rutas de error) proviene de mezclar **memoria GC (JavaScriptCore) × memoria manual (Zig)** — un caso para el que pocos lenguajes están diseñados. En **Rust seguro**, estos se convierten en **errores de compilación** + limpieza automática (`Drop`, RAII). «Los errores del compilador son un mejor bucle de retroalimentación que una guía de estilo». Zig favorece el `defer` explícito (sin flujo de control oculto); la alternativa — smart pointers caseros — ofrecía «una ergonomía peor que la de Rust, sin las garantías».
- **La restricción que hace viable la apuesta: una suite de pruebas independiente del lenguaje.** Las pruebas de Bun están **escritas en TypeScript** → no dependen del lenguaje de implementación. El port busca un **cambio mínimo de comportamiento**, validado por esta suite (60.624 pruebas, 1,39M de llamadas `expect()`, **0 pruebas eliminadas u omitidas**, verificado a mano). Esta es la red de seguridad que permite fusionar 1M de líneas generadas por un LLM.
- **Port mecánico > rediseño.** Elección explícita: preservar la arquitectura de Zig, minimizar los cambios, dejar el Rust **idiomático** para *después* del lanzamiento de v1.4. «¿Incremental o todo a la vez?» → todo a la vez (como en su port original de esbuild de Go a Zig, sin LLM). Todo lo demás «es solo táctica».
- **El harness: ~50 flujos de trabajo dinámicos en Claude Code, en bucle durante 11 días.** Pseudocódigo tal como se expone: `while (task = todo.pop()) { result = task(); feedback = await [review(result), review(result)]; apply(feedback) }`. Flujos de trabajo dedicados: generar la guía de porting → portar mecánicamente cada archivo `.zig` a `.rs` → corregir errores de compilación por crate → conseguir que pasen los subcomandos (`bun test`, `bun build`) → conseguir que pase toda la suite → refactorizaciones/limpieza.
- **La revisión adversarial, el núcleo de la fiabilidad.** Un **segundo Claude, en un contexto separado, que ve ÚNICAMENTE el diff** (nada del razonamiento del implementador), encargado de «encontrar por qué está mal». Proporción de **1 implementador / 2+ revisores adversariales / 1 corrector**; el implementador no revisa, el revisor no implementa (como con los humanos, la persona que escribe el código está sesgada a favor de fusionarlo). Detecta errores que son **sintácticamente idénticos pero semánticamente distintos**: un `Box` liberado antes de un `uv_close` asíncrono (UAF + double-free); un timespec negativo vía `trunc` frente a `floor`; un `unwrap_or` **eager** que provoca un panic donde un `unwrap_or_else` **lazy** no lo habría hecho.
- **«Corregir el proceso que genera el código, no el código a mano.»** Principio rector: cuando aparece un error o un antipatrón, se edita el **flujo de trabajo/prompt**, no el archivo. P. ej.: cuando Claude añade comentarios largos para justificar workarounds, se añade una regla para los revisores → *«Si necesitas un comentario de un párrafo entero para justificar por qué el workaround está bien, el código está mal — corrige el código.»* Una edición de prompt, unas horas, y el comportamiento desaparece.
- **Preparación (reducción de riesgo) antes de escribir una sola línea.** ~3 horas de discusión con Claude → **PORTING.md** (mapeo de patrones/tipos Zig→Rust). Luego un flujo de trabajo que analiza **la duración de vida de cada campo de struct** (lectura + rastreo de flujo de control, 2 revisores adversariales), serializado en **LIFETIMES.tsv** para las demás instancias de Claude. Luego una **prueba piloto sobre 3 archivos** antes de lanzarse sobre los 1.448.
- **El paralelismo y sus falsos inicios.** Lanzar los 1.448 archivos de golpe → las instancias de Claude colisionan (`git stash`/`stash pop`/`reset --hard`). Solución: **prohibir cualquier operación git que no haga commit de un archivo específico**, nada de `cargo`, ni comandos lentos. Luego **4 shards / 4 worktrees × 16 Claude** = **~64 instancias de Claude** simultáneamente. Pico: **1.300 líneas/min**, **695 commits/h**, 58 commits/min. Un `grep` lento bloqueó el disco por IOPS insuficientes en la instancia EC2.
- **~16.000 errores de compilación tratados como una cola.** Divididos en **~100 crates** (compilación más rápida) → revela **dependencias cíclicas** (el código de Zig era una única unidad de compilación) → flujos de trabajo de clasificación seguidos de flujos de trabajo de refactorización. `cargo check` escribe los errores en un archivo agrupado por crate → distribuido entre 64 instancias de Claude. Aislamiento reforzado mediante **systemd-run (cgroups)** para las pruebas de fugas de memoria/estrés (10k procesos, gigabytes de disco saturado, sockets TCP saturados).
- **El camino hacia el verde (Buildkite CI, 6 plataformas).** De 972 archivos de prueba fallando a 23 en 2 días; Linux totalmente en verde ~1 día antes que Windows; build #54202 = **6/6 plataformas en verde** → fusión. Fusionar ≠ publicar: suficiente confianza para hacer commit, todavía no para lanzar.
- **Coste, cuantificado y asumido.** Antes de la fusión: **5,9 mil millones de tokens de entrada sin caché + 690M de salida + 72 mil millones de lecturas de caché ≈ 165.000 $** a precios de API. Alternativa humana realista: **3 ingenieros, ~1 año**, durante el cual «no habríamos mejorado la compatibilidad con Node.js, corregido errores/vulnerabilidades, ni lanzado funcionalidades» — por tanto **nunca se habría hecho**. «La alternativa realista era no hacer nada y seguir corrigiendo los errores para siempre».
- **Tras la fusión, el trabajo continúa.** **11 rondas** de revisión de **Claude Code Security**; **fuzzing guiado por cobertura 24/7** de todos los parsers (JS/TS/JSX/CSS/JSON5/TOML/YAML/Markdown/INI/Bun Shell/semver/.patch), **100 mil millones de ejecuciones → ~15 PR** (el fuzzer envía la reproducción a Claude, que presenta el PR, seguido de revisión humana). **~4% de código `unsafe`** (~13.000 bloques `unsafe` / ~780.000 líneas), de los cuales **78% en una sola línea** (un puntero procedente de C++ o de una llamada C) — se espera que disminuya a medida que se avance hacia Rust idiomático. **19** regresiones conocidas, todas corregidas (p. ej., la macro `debug_assert!` eliminada en los builds de release → HMR roto).
- **El modelo y la producción.** Una versión preliminar de **Claude Fable 5** («un modelo de clase Mythos»); los flujos de trabajo dinámicos de Claude Code sostuvieron **64 instancias de Claude durante 11 días** («de lo contrario habría tenido que escribir mi propio harness»). Primera versión sobre Bun-en-Rust: **Claude Code v2.1.181**, **+10% de arranque más rápido en Linux**, cambios mínimos visibles para el usuario → prueba de madurez para producción.
- **Relacionado**: revisión de código basada en agentes / verificación adversarial y consenso («The End of Code Review» de Monperrus, la serie ADLC al estilo Kent Beck «prosecution not code review» / «tests are the spec»); **Loop/Harness Engineering** (Lushbinary, Osmani, OpenAI Codex agent-first, la técnica Ralph, git worktrees); skills de Claude Code y flujos de trabajo dinámicos; Zig ya presente en el corpus (ZML/LLMD, soberanía del silicio); FinOps de tokens / coste por resultado.

## RésuméDe400mots

Jarred Sumner, creador de **Bun** (runtime JS/TS, >22M de descargas/mes, adquirida por **Anthropic** en diciembre de 2025), relata la **reescritura completa de Bun de Zig a Rust en 11 días** (3→14 de mayo de 2026), impulsada por Claude. La motivación es una clase recurrente de errores — use-after-free, double-free, fugas — derivada de la mezcla de memoria gestionada por GC (JavaScriptCore) y memoria manual (Zig). En **Rust seguro**, estos errores se convierten en **errores de compilación** con limpieza automática (`Drop`/RAII): «un mejor bucle de retroalimentación que una guía de estilo».

Frente al dogma de que «una reescritura siempre es una mala idea» (un año de congelación de corrección de errores para 3 ingenieros sobre 535.496 líneas de Zig), Sumner opta por un **port mecánico**: preservar la arquitectura, minimizar los cambios de comportamiento, validar contra la **suite de pruebas existente — escrita en TypeScript, y por tanto independiente del lenguaje** (60.624 pruebas, 1,39M de aserciones, 0 pruebas eliminadas, 6 plataformas).

El harness: **~50 flujos de trabajo dinámicos** en **Claude Code**, en bucles de *escritura → revisión → aplicación*, ejecutándose de forma continua. El pilar de la fiabilidad es la **revisión adversarial**: un segundo Claude, en un **contexto separado que ve únicamente el diff**, encargado de «encontrar por qué está mal». Proporción de **1 implementador / 2+ revisores / 1 corrector**; el implementador no revisa su propio trabajo. Detecta errores sutiles que son sintácticamente idénticos pero semánticamente distintos (un `Box` liberado antes de un `uv_close` asíncrono; un `unwrap_or` eager que provoca un panic). Principio cardinal: **«corregir el proceso que genera el código, no el código a mano»** — cuando aparece un antipatrón, se edita el prompt/flujo de trabajo.

Preparación meticulosa: **PORTING.md** (mapeo Zig→Rust) y **LIFETIMES.tsv** (duración de vida de cada campo de struct), una prueba piloto sobre 3 archivos antes de los 1.448. Luego **4 worktrees × 16 = ~64 instancias de Claude** en paralelo, tras prohibir todas las operaciones git no atómicas. Pico: **1.300 líneas/min**, **695 commits/h**; **6.502 commits**, diff **+1.009.272 líneas**, ~16.000 errores de compilación tratados como una cola (divididos en ~100 crates, resolviendo dependencias cíclicas).

Coste revelado: **5,9 mil millones de tokens de entrada sin caché + 690M de salida ≈ 165.000 $**, frente a ~3 ingenieros durante un año — «algo que nunca habríamos hecho». Modelo: una versión preliminar de **Claude Fable 5** (clase Mythos). Desde la fusión: **11 rondas** de revisión de seguridad con Claude Code, fuzzing 24/7 (100 mil millones de ejecuciones → ~15 PR), **4% de código `unsafe`**, **19 regresiones** corregidas. Primera versión: Claude Code v2.1.181, **+10% de arranque más rápido en Linux**. «Esto es la vanguardia de lo que es posible hoy en día».

## GrapheDeConnaissance

- Jarred Sumner —a_créé→ Bun (TECHNOLOGIE, 0.98)
- Bun —fait_partie_de→ Anthropic (ORGANISATION, 0.95)
- Jarred Sumner —travaille_chez→ Anthropic (ORGANISATION, 0.95)
- Jarred Sumner —utilise→ Claude Fable 5 (TECHNOLOGIE, 0.95)
- Bun —utilise→ Rust (TECHNOLOGIE, 0.97)
- Rust —remplace→ Zig (TECHNOLOGIE, 0.9)
- Rust —réduit→ use-after-free, double-free et fuites mémoire (erreurs de compilation en safe Rust) (AFFIRMATION, 0.9)
- Claude Fable 5 —permet→ réécriture mécanique de Bun de Zig vers Rust en 11 jours (AFFIRMATION, 0.9)
- réécriture de Bun en Rust —utilise→ dynamic workflows (METHODOLOGIE, 0.95)
- dynamic workflows —utilise→ revue adversariale (METHODOLOGIE, 0.92)
- revue adversariale —réduit→ régressions du code généré par LLM (CONCEPT, 0.88)
- Claude Code —permet→ ~64 Claude en parallèle pendant 11 jours (4 worktrees × 16) (AFFIRMATION, 0.9)
- réécriture de Bun en Rust —utilise→ suite de tests TypeScript indépendante du langage (CONCEPT, 0.92)
- Jarred Sumner —mesure→ ~165 000 $ (5,9 Md tokens d'entrée non cachés, 690 M en sortie) pour la réécriture (MESURE, 0.9)
- Jarred Sumner —recommande→ corriger le processus qui génère le code plutôt que le code à la main (AFFIRMATION, 0.9)
- Bun —utilise→ JavaScriptCore (TECHNOLOGIE, 0.9)
- Claude Code —utilise→ Bun (TECHNOLOGIE, 0.9)
- Bun (réécrit en Rust) —améliore→ démarrage de Claude Code de ~10 % sur Linux (MESURE, 0.85)
- coverage-guided fuzzing —résout→ bugs de parsers de Bun (100 Md exécutions → ~15 PRs) (AFFIRMATION, 0.85)
- Jarred Sumner —affirme_que→ one engineer can do a lot more today than a year ago (CITATION, 0.9)

---
Canonical: https://www.thekb.eu/es/fiches/sumner-bun-rewrite-rust-claude-2026-07-08/