Bun a Anthropic, Astral a OpenAI: la infraestructura IA se mudó a Rust

⏱️ Lectura: 14 min

En abril de 2026, el machine learning engineer Noah Mitchem publicó en Medium un ensayo titulado If AI Writes Your Code, Why Use Python? que escaló hasta el puesto #3 semanal de Hacker News con 892 puntos. Su tesis incomoda a la mayoría del ecosistema: si los agentes IA son los que efectivamente escriben el código, las ventajas ergonómicas que llevaron a Python al trono dejan de importar. La elección de lenguaje vuelve a ser una decisión técnica, no de productividad humana.

📑 En este artículo

1. TL;DR
2. ¿Qué es la tesis Mitchem?
3. ¿Cómo funciona la retroalimentación con agentes?
4. Proyectos reales: los datos que rompen el debate
   1. TypeScript 7.0 (Microsoft, beta)
   2. Compilador C en Rust (Anthropic, Nicholas Carlini)
   3. Lenguaje Rue (Steve Klabnik)
   4. Ladybird JavaScript Engine (Andreas Kling)
5. El ecosistema Python ya es Rust con sombrero
   1. Astral y la apuesta de OpenAI
   2. Bun y Anthropic
   3. Rolldown-Vite y el techo de JavaScript
6. De parches a ports completos
7. Ejemplo práctico: el mismo endpoint, dos lenguajes
8. Instalación en Windows, macOS y Linux
9. Casos de uso: ¿cuando aplica la tesis?
10. Ventajas y desventajas honestas
    1. Ventajas
    2. Desventajas y limitaciones
11. ¿Qué significa para devs en LATAM?
12. Preguntas frecuentes
    1. ¿Mitchem está diciendo que Python va a morir?
    2. ¿Qué pasa con los lenguajes pequeños como Zig o Gleam?
    3. ¿Necesito saber Rust para usar agentes que escriban Rust?
    4. ¿Cuánto cuesta realmente portar un proyecto con agentes?
    5. ¿Cambia esto como entreno a juniors?
    6. ¿Y los ML engineers? ¿Python sigue?
13. Referencias
    1. 📚 Artículos relacionados

Las cifras que sostienen el argumento son recientes y verificables. Anthropic adquirió Bun. OpenAI compró Astral. Microsoft reescribió el compilador de TypeScript en Go. Nicholas Carlini construyó un compilador C en Rust con 16 agentes Claude por $20.000. Antes de aceptar o rechazar la tesis, conviene mirar los datos.

TL;DR

• Mitchem (ex-IBM, ahora founding engineer en Real Hire) sostiene que la ventaja «fácil para humanos» de Python desaparece cuando quien tipea es un agente IA.
• Claude Opus 4.7, GPT-5.5, Gemini 3.1 y DeepSeek V4 superaron el 80% en SWE-bench Verified en abril 2026 — todos en semanas de diferencia.
• Nicholas Carlini (Anthropic) orquestó 16 agentes Claude en paralelo: 100.000 LOC de un compilador C escrito en Rust por $20.000 en 2.000 sesiones de Claude Code.
• Anthropic adquirió Bun (7M descargas/mes, 89k stars). OpenAI compró Astral el 19 de marzo de 2026 — uv ahorra ~1M minutos de cómputo semanal a Codex.
• TypeScript 7.0 reescribió su compilador en Go: beta ~10x más rápida que la 6.0. Hejlsberg eligió Go sobre Rust por costo de ingeniería.
• Steve Klabnik construyó el lenguaje Rue (70.000 LOC de Rust) en dos semanas con agentes. Andreas Kling portó el motor JS de Ladybird de C++ a Rust en dos semanas, byte-for-byte parity.
• Honestidad: Python sigue dominando entrenamiento ML (PyTorch en ~85% de papers). La tesis aplica al próximo proyecto, no a migrar lo existente.

¿Qué es la tesis Mitchem?

Durante una década, dos lenguajes acapararon la conversación: Python y TypeScript. Ambos ganaron por la misma razón económica. Fast-to-ship beat fast-to-run. Tipado dinámico, sintaxis liviana, REPL inmediato. La fricción humana — recordar tipos, escribir traits, esperar al compilador — costaba más caro que los ciclos de CPU desperdiciados en runtime.

Mitchem observa que esa ecuación se invirtió en silencio. Cuando un agente IA escribe el código:

• El tipado fuerte deja de ser una carga: es información gratis para el modelo.
• El compilador rápido deja de ser opcional: es la señal de entrenamiento que cierra el loop.
• La verbosidad deja de ser problema: el agente no se cansa de escribir.

💭 Clave: los lenguajes que penalizaban a humanos hoy recompensan a agentes. Rust fue, en palabras de Mitchem, «accidentalmente diseñado para desarrollo asistido por IA diez años antes de que alguien supiera que eso importaba».

¿Cómo funciona la retroalimentación con agentes?

El argumento técnico central tiene tres capas. La primera es de capacidades: para abril de 2026, los principales LLMs (Claude Opus 4.7, GPT-5.5, Gemini 3.1, DeepSeek V4) superaron el 80% en SWE-bench Verified en semanas de diferencia. Los labs optimizaron especificamente para los problemas duros: bugs de concurrencia, race conditions, fallas arquitectónicas. Justo lo que un sistema de tipos fuerte ayuda a prevenir.

La segunda es el loop de retroalimentación. Un agente que escribe Rust ejecuta este ciclo:

1. Genera código → cargo check
2. Lee errores del compilador → ajusta
3. Repite hasta que compila
4. cargo test → confirma comportamiento

Cada pasó es una señal estructurada y barata. En Python, el equivalente requiere ejecutar el código y observar errores en runtime — más lento, más caro, y con cobertura incompleta. Como sintetizó el usuario CtrlAltDwayne en X: «El mejor argumento para Rust en 2026 ya no es memory safety ni performance. Es que la IA escribe mejor Rust que C++. El loop del compilador es tan apretado que los modelos se autocorrigen en tiempo real».

La tercera capa es ecosistema. Hace dos años, GPT-4 alucinaba nombres de crates. Hoy los modelos tienen suficiente training data verificable (millones de repos compilando contra crates.io) para producir código que pasa CI sin intervencion humana.

graph LR
  A["Agente IA"] --> B["Genera código Rust/Go"]
  B --> C["cargo check / go vet"]
  C -->|"error"| D["Lee diagnostico"]
  D --> B
  C -->|"ok"| E["cargo test"]
  E -->|"fail"| D
  E -->|"pass"| F["Commit"]

Proyectos reales: los datos que rompen el debate

Mitchem no se queda en lo teórico. Lista proyectos concretos, todos de los últimos meses, todos verificables.

TypeScript 7.0 (Microsoft, beta)

Microsoft reescribió el compilador de TypeScript en Go. La beta de TypeScript 7.0 corre aproximadamente 10x más rápido que la 6.0. Anders Hejlsberg, creador original del lenguaje, explicó la elección: «Most of the performance benefit at a fraction of the engineering cost». Eligió Go sobre Rust deliberadamente. La conclusión no es «Rust gana siempre» — es «el lenguaje correcto deja de estar bloqueado por el costo humano».

Compilador C en Rust (Anthropic, Nicholas Carlini)

Carlini orquestó 16 agentes Claude en paralelo. Resultado:

• 100.000 lineas de Rust.
• Arranca Linux 6.9 en x86, ARM y RISC-V.
• Compila QEMU, FFmpeg, SQLite, PostgreSQL y Redis.
• Costo total: $20.000 en 2.000 sesiones de Claude Code.

La frase de Carlini que cierra el caso: un compilador C «used to be a graduate thesis. It isn’t anymore«. El umbral de que constituye trabajo «duro» se desplazó.

Lenguaje Rue (Steve Klabnik)

Klabnik, co-autor de The Rust Programming Language y con 13 años de experiencia, construyó un nuevo lenguaje de sistemas en dos semanas, 70.000 lineas de Rust. Su comentario: «Avancé más en las dos semanas que llevo trabajando esta vez que en el mes o dos que dedique la vez anterior».

Ladybird JavaScript Engine (Andreas Kling)

Andreas Kling portó el motor JavaScript del navegador Ladybird de C++ a Rust en dos semanas: 25.000 lineas con byte-for-byte parity. Cero regresiones en más de 65.000 tests combinados (test262 + Ladybird). Comentario de Kling: «El mismo trabajo manual me hubiera tomado varios meses».

El ecosistema Python ya es Rust con sombrero

Para devs en LATAM que aprendieron Python primero, este dato puede sorprender: gran parte del ecosistema que usas ya esta escrito en Rust. Una lista corta:

• pydantic v2 — validación, núcleo en Rust.
• polars — alternativa a pandas, ~10x más rápido, Rust nativo.
• Hugging Face tokenizers — Rust.
• orjson — parser JSON, Rust.
• ruff — linter de Python, Rust.
• uv — gestor de paquetes Python, Rust.

La encuesta JetBrains 2025 mostró que el uso de Rust para extensiones binarias de Python saltó del 27% al 33% en un año. En palabras de Mitchem: The Python ecosystem is increasingly a Rust ecosystem wearing a Python hat.

Astral y la apuesta de OpenAI

Astral, fundada en 2022 por Charlie Marsh, creó tres herramientas que pasaron de cero a cientos de millones de descargas mensuales en menos de tres años:

• ruff — linter.
• uv — package manager.
• ty — type checker.

OpenAI adquirió Astral el 19 de marzo de 2026. La justificación interna filtrada: «uv le ahorra a Codex aproximadamente un millón de minutos de cómputo por semana«. Cuando los agentes son tu mayor usuario, herramientas en Rust dejan de ser opcionales.

Bun y Anthropic

Anthropic adquirió Bun, con 7 millones de descargas mensuales y 89.000 stars en GitHub. La justificación pública: «infraestructura esencial para ingeniería de software liderada por IA». El mensaje es directo: si los agentes corren tus pipelines, los pipelines tienen que ser rápidos y deterministas.

Rolldown-Vite y el techo de JavaScript

Evan You (creador de Vue) lanzó Rolldown-Vite, el nuevo bundler de Vite escrito en Rust. Redujo el build de GitLab de 2,5 minutos a 40 segundos con 100x less memory. Lee Robinson (VP Product, Vercel) lo resumió: «hemos alcanzado el techo de optimización con JS».

De parches a ports completos

Armin Ronacher (creador de Flask) portó su libreria MiniJinja a Go usando agentes:

• 10 horas totales (3 supervisadas, 7 sin supervisión).
• 45 minutos de tiempo humano real.
• Costo de API: $60.

Ronacher: el valor se esta moviendo del código a los tests y la documentación. Un buen test suite podría valer más que el código en si. Mitchem extiende la observación con una pregunta retórica: Why patch what you can fork?. Si portar una libreria entera cuesta horas y decenas de dolares, los upstreams pierden parte de su gravedad.

💡 Tip: si vas a empezar un proyecto greenfield en 2026, evalua Rust o Go con asistencia de agentes antes de defaultear a Python. La curva de aprendizaje sigue ahí — pero la curva de productividad cambio.

Ejemplo práctico: el mismo endpoint, dos lenguajes

Comparemos un endpoint trivial en Python y en Rust con un agente IA generando ambos. La métrica no es performance — es facilidad para el agente de producir código correcto a la primera.

Python (FastAPI):

from fastapi import FastAPI
from pydantic import BaseModel

class User(BaseModel):
    id: int
    email: str
    age: int | None = None

app = FastAPI()

@app.post("/users")
async def create_user(user: User):
    # ¿que pasa si age es negativo? ¿si email no es email?
    return {"created": user.id}

Funciona, pero los chequeos quedan implicitos. Un agente puede olvidar validaciones de borde.

Rust (Axum + serde):

use axum::{routing::post, Json, Router};
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize)]
struct User {
    id: u64,
    email: String,
    #[serde(default)]
    age: Option<u8>,
}

async fn create_user(Json(user): Json<User>) -> Json<serde_json::Value> {
    Json(serde_json::json!({ "created": user.id }))
}

#[tokio::main]
async fn main() {
    let app = Router::new().route("/users", post(create_user));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

El tipo u8 ya impide edades negativas o mayores a 255 a nivel de deserialización. El compilador rechaza usos incorrectos antes de ejecutar nada. El agente recibe feedback inmediato si la firma cambia. Es más código que el equivalente Python, si — pero el agente no se cansa de tipearlo.

Instalación en Windows, macOS y Linux

Si querés probar el stack que Mitchem describe, así se instalan las herramientas clave en las tres plataformas:

uv (gestor de paquetes Python en Rust):

# macOS y Linux
curl -LsSf https://astral.sh/uv/install.sh | sh

# Windows (PowerShell)
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Rust (toolchain via rustup):

# macOS y Linux
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Windows: descargar rustup-init.exe desde rustup.rs

Bun (runtime adquirido por Anthropic):

# macOS y Linux
curl -fsSL https://bun.sh/install | bash

# Windows (PowerShell)
powershell -c "irm bun.sh/install.ps1 | iex"

Casos de uso: ¿cuando aplica la tesis?

• Nuevos servicios backend donde la performance importa: Go o Rust con agentes ya son competitivos en velocidad-de-entrega.
• CLIs distribuidos: binarios estáticos en Rust o Go simplifican el ship.
• Infraestructura crítica (compiladores, runtimes, daemons): los datos de Carlini y Klabnik muestran que es viable.
• Bibliotecas con cuello de botella: si tu Python depende de polars o pydantic, ya estás pagando por Rust.

Ventajas y desventajas honestas

Ventajas

• Compilador como tutor: cero costo marginal por iteración del agente.
• Determinismo: el código compilado se comporta igual en CI, produccion y la laptop del dev.
• Performance gratis, sin micro-optimizar a mano.
• Menor superficie de bugs en runtime.

Desventajas y limitaciones

• Python sigue dominando ML training: PyTorch aparece en ~85% de papers de ML. La tesis es sobre aplicaciones, no entrenamiento.
• Lenguajes minoritarios sufren: el propio Mitchem admite que Zig, Gleam y Haskell tienen training data insuficiente. Stack Overflow 2025 los muestra como most admired (Rust 72%, Gleam 70%, Elixir 66%, Zig 64%), pero los agentes no los escriben tan bien.
• Devs sin Rust quedan dependientes del agente: leer y depurar el código sigue requiriendo conocimiento humano.
• Costo de API: $20.000 por un compilador C es barato comparado con un graduate student, pero no es cero.

⚠️ Ojo: «el agente escribe Rust» no significa «tu equipo no necesita saber Rust». Significa que la barrera de entrada bajó, no que desapareció. Code review sigue siendo humano.

¿Qué significa para devs en LATAM?

La mayoría de cursos en español arranca con Python por una razón valida: la curva inicial es plana. La tesis Mitchem no invalida ese punto de entrada. Si cambia la respuesta a «¿que lenguaje aprendo después?».

Si tu objetivo es trabajar en infraestructura, sistemas embebidos, herramientas de developer experience o backend de alta carga, invertir tiempo en Rust o Go con asistencia de Claude Code o Codex en 2026 paga más rápido que hace dos años. La paradoja: el lenguaje «difícil» se vuelve más accesible justamente cuando los agentes hacen la parte difícil.

Andrej Karpathy lo formuló así: LLMs change the whole constraints landscape of software completely… incluso Rust está lejos del óptimo. La discusión de qué lenguaje viene después de Rust ya está abierta.

📖 Resumen en Telegram: Ver resumen

Preguntas frecuentes

¿Mitchem está diciendo que Python va a morir?

No. La frase exacta del ensayo es: the next project you start doesn’t have to default to Python. Es una pregunta sobre el próximo proyecto greenfield, no una predicción de muerte. Python sigue siendo dominante en ML, ciencia de datos y scripting.

¿Qué pasa con los lenguajes pequeños como Zig o Gleam?

Sufren un problema circular: poca adopción lleva a poco training data, lo que genera agentes mediocres, lo que reduce la adopción. Mitchem lo reconoce explicitamente. Stack Overflow 2025 los muestra como aspiracionalmente populares, pero los agentes los escriben peor que Rust o Go.

¿Necesito saber Rust para usar agentes que escriban Rust?

Sí, para leer, depurar y revisar. La tesis es que escribir deja de ser el cuello de botella, no que entender el código deje de importar. Armin Ronacher destaca que ahora valen más los tests y la documentación.

¿Cuánto cuesta realmente portar un proyecto con agentes?

Datos concretos del ensayo: Ronacher portó MiniJinja a Go por $60 más 45 minutos de supervisión. Carlini escribió 100k LOC de un compilador C en Rust por $20.000. Kling portó un motor JS de C++ a Rust en dos semanas. La variable es supervisión humana, no tokens.

¿Cambia esto como entreno a juniors?

Probablemente si. Si los agentes hacen el fast-to-ship, el valor diferencial humano pasa a ser diseño de tests, arquitectura, revision, y entender que no hacer. Los bootcamps que enseñan solo Python pueden quedarse cortos.

¿Y los ML engineers? ¿Python sigue?

Sí, en training. PyTorch y JAX dominan el research (~85% de papers). El cambio aplica más a inferencia, infraestructura y producto. Polars, ruff, uv, pydantic y compañía ya están haciendo la migración debajo sin que el usuario Python lo note.

Referencias

• Noah Mitchem — If AI Writes Your Code, Why Use Python? — ensayo original en Medium, abril 2026 (#3 semanal en Hacker News con 892 puntos).
• microsoft/typescript-go — repositorio publicó del port de TypeScript a Go liderado por Anders Hejlsberg.
• astral.sh — sitio oficial de Astral (ruff, uv, ty), adquirida por OpenAI el 19 de marzo de 2026.
• LadybirdBrowser/ladybird — navegador Ladybird, donde Andreas Kling portó el motor JavaScript a Rust.
• bun.sh — runtime de JavaScript adquirido por Anthropic, infraestructura clave para pipelines IA.

📱 ¿Te gusta este contenido? Únete a nuestro canal de Telegram @programación donde publicamos a diario lo más relevante de tecnología, IA y desarrollo. Resúmenes rápidos, contenido fresco todos los días.