Description
Un agente de IA te va a entregar Rust que compila, parece idiomático y está mal en silencio: clona para callar al borrow checker, envuelve todo en un lock que después sostiene cruzando un await, hornea un secreto dentro de la imagen, escribe un test confiado que no verifica nada. El compilador deja pasar casi todo eso, porque el compilador garantiza seguridad de memoria, no buenas decisiones. Los tutoriales de sintaxis no te sirven acá, no sos vos quien tipea la sintaxis. Lo que te falta es el modelo mental del revisor: qué está haciendo Rust en realidad por debajo del código, para poder mirar un diff y saber si va a producción o vuelve para atrás.
Este libro te entrena para ser el revisor de Rust vibe-codeado, no para memorizar el lenguaje. Arranca desde una premisa distinta a la de cualquier otro libro de Rust: el agente escribe el código, y tu palanca es entender qué hace ese código en realidad para poder revisarlo con el criterio que el compilador no tiene. Vas a aprender qué está garantizando de verdad el borrow checker, qué hace el async de Rust detrás de un await, cómo Actix sirve un request, qué hacen realmente un ORM y un pool de conexiones, y cómo las piezas se integran en un servicio que corre, y vas a aprender todo eso como lo necesita un revisor: leyendo código real que el agente generaría y decidiendo qué está bien, qué es plausible pero peligroso y qué hay que devolver. La progresión va de revisar una sola decisión de ownership, a revisar un componente como la capa de datos o la superficie de autenticación, a revisar cómo encaja todo el sistema y dónde se va a romper bajo carga. Acá casi no hay ejercicios de sintaxis y sí mucho sobre arquitectura, concurrencia, fallas y las formas específicas en que el Rust de un agente sale mal. Para ingenieros que van a vibe-codear en Rust de todas formas y quieren ser los que cazan lo que se le escapó al modelo.
¿Este libro es para vos?
Este libro es para: ingenieros que ya decidieron dejar que un agente de IA escriba su Rust (vibe coding) y ahora se quedan con la parte que el agente no puede hacer, que es juzgar si lo que produjo es correcto, seguro y está bien diseñado, y que no piensan pasarse meses moliendo tutoriales de sintaxis para llegar ahí.
El índice completo
- Capítulo 1: No escribiste este Rust, pero sos vos quien lo pone en producción
- Capítulo 2: Lo que el arreglo del agente al borrow checker te cuesta en silencio
- Capítulo 3: ¿Este tipo hace imposible el dato inválido, o solo posible de validar?
- Capítulo 4: Tu contrato REST es una promesa sobre la que otros van a construir
- Capítulo 5: Por qué “compila y anda” todavía no te dice nada
- Capítulo 6: Código de base de datos que falla solo bajo carga o ataque
- Capítulo 7: ¿Esto de verdad necesitaba un actor, o solo quedaba impresionante?
- Capítulo 8: ¿Este estado compartido corre en paralelo, o se serializa bajo carga?
- Capítulo 9: Cuando una llamada a una API externa se vuelve tu caída
- Capítulo 10: Un login que parece seguro y está abierto de par en par
- Capítulo 11: Lo que vas a desear que los logs te dijeran a las 3 de la mañana
- Capítulo 12: Por qué tus handlers async quizás corren de a uno
- Capítulo 13: La parte de tu servicio que te miente sin despeinarse
- Capítulo 14: Tests en verde que nunca atraparían un bug real
- Capítulo 15: El secreto filtrado que convierte un deploy en una brecha
