Los LLMs escriben Rust con siete categorías de errores ocultos que el compilador no detecta

Un desarrollador pasó seis meses usando Claude, GPT y Cursor como un programador Rust de tiempo completo en código de producción. Durante este período, rastreó cuidadosamente los errores y compiló una lista impresionante: siete categorías de errores que los LLM cometen sistemáticamente. Lo más preocupante — estos errores pasan el compilador, las pruebas unitarias e incluso el analizador estático clippy. Sin embargo, violan la seguridad de memoria o destruyen la arquitectura de la aplicación.

Siete Tipos de Errores Ocultos

Aquí están las categorías que los LLM rompen una y otra vez:

• Lifetime laundering — variables viven más tiempo del que permite el sistema de tipos de Rust. Esto conduce a use-after-free en tiempo de ejecución.
• Mutex through await — un bloqueo que mantiene el mutex durante la espera asíncrona. Deadlock garantizado.
• Drop en transacciones — olvidan llamar drop cuando necesitan cerrar un recurso (cerrar archivo, revertir transacción). Pérdida de recursos.
• Unaligned read — desreferencia de memoria con alineación incorrecta. El procesador se bloquea en ARM, se rompe silenciosamente en x86.
• Async cancellation — cancelación incorrecta de operaciones asíncronas. Deja estados suspendidos.
• Orphan rule — violación de la regla orphan al implementar traits. Se compila en un proyecto, se rompe al agregar una dependencia.
• Matrices en la pila — asignación de matrices enormes en la pila (en lugar del heap). Desbordamiento de pila, segfault.

Por Qué Esto Es Peligroso para Producción

El punto de Rust es que el compilador detecta errores durante el desarrollo, no en la producción. Pero estos siete errores escapan al compilador — porque no violan la sintaxis o las reglas de tipado formal. Como resultado, el código compila sin advertencias, pasa las pruebas unitarias, se ejecuta a través de clippy y se envía a producción. Todo se rompe allí, pero es demasiado tarde. Esto es peor que un error explícito del compilador, porque el desarrollador está seguro de que todo está bien.

Por Qué Los LLM Rompen Esto

Rust es un lenguaje marginal en el conjunto de datos de los LLM. Python, JavaScript y Java representan el 70% del código en el que fueron entrenados los modelos. Rust — tal vez 2-3%. Además, Rust requiere una comprensión profunda de ownership, lifetimes y del sistema de tipos, que los LLM entienden solo superficialmente. Los modelos ven patrones y los copian. Saben que 'usualmente escribes así', pero no saben por qué funciona en Java y se rompe en Rust. Por lo tanto, reproducen patrones incorrectamente, creando la ilusión de código compilable.

Rust rompe LLMs porque es un lenguaje en el que tienes que pensar, no

solo copiar patrones.

Conclusiones Prácticas

El desarrollador no aconseja abandonar completamente los LLM, pero recomienda:

• No confíes en LLM para secciones críticas: criptografía, operaciones de memoria, concurrencia
• Exigir revisión formal de código incluso si el compilador no se queja
• Usa Miri — un intérprete que detecta comportamiento indefinido durante el desarrollo
• Aprende Rust lo suficiente para escribir código tú mismo o poder encontrar errores en el código LLM

Lo Que Esto Significa

Los LLM son una herramienta útil, pero no un reemplazo para los humanos. En lenguajes dinámicos, funcionan bien (Python, JavaScript), porque hay menos reglas que necesitan ser entendidas intuitivamente. En Rust, necesitas verificar cada línea o mantener humanos en el bucle de decisión. Para frameworks como Next.js o Django, un asistente LLM es un acelerador poderoso. Para Rust en producción, es más un borrador para revisión humana que un colega completo.