Ingeniero Blockchain: Pocos ingenieros saben hacer esto, y por eso las empresas lo pagan tanto. Aprendé a construir y auditar sistemas on-chain reales, y entrá ahora que todavía sos de los pocos.

Description

BLOCKCHAIN: Entendé de verdad cómo funciona una blockchain por dentro: el consenso, la criptografía, las transacciones, los bloques y la máquina virtual

Este libro te entrena para ser el revisor de sistemas blockchain vibe-codeados, no para memorizar Solidity. Arranca desde una premisa que el hype se saltea: sobre un ledger inmutable el agente escribe el código, pero las consecuencias son tuyas, así que tu palanca es entender qué está haciendo de verdad la máquina de abajo. Vas a aprender qué garantiza en realidad el consenso y por qué una transacción confirmada todavía no está saldada, qué hace la EVM cuando corre tu contrato, qué prueban de verdad el hashing y las firmas y dónde los podés reusar, y cómo funcionan las pruebas de conocimiento cero, los oráculos, los rollups y los puentes entre cadenas al nivel que necesita un revisor y no al que vende un whitepaper. Lo vas a aprender como lee el código un atacante: recorriendo funciones reales que un agente generaría para una sola bóveda DeFi que corre, y decidiendo qué es seguro, qué es plausible pero explotable y qué hay que devolver. La progresión va de revisar una sola función, a revisar un componente como la bóveda o la integración con el oráculo, a revisar todo el sistema entre upgrades, deployment en una capa dos, puentes, una auditoría y la respuesta al incidente para cuando la prevención falló. Casi no hay ejercicios de sintaxis y sí mucho sobre decisiones, modos de falla y las formas específicas en que el código on-chain de un agente sale mal. Para ingenieros que van a deployar contratos de todas formas y quieren ser los que cazan lo que se le escapó al modelo antes de que la cadena lo vuelva permanente.

RUST: Aprendé Rust desde la base y construí servicios confiables que sabés revisar sin sorpresas

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.

VIBE CODING: Volvete el programador que la IA multiplica en vez de reemplazar, el que aporta el juicio que a la máquina todavía le falta

Esta guía revela el secreto que separa al programador que la IA reemplaza del que vuelve imprescindible: el vibe coding no es una colección de prompts, es ingeniería de software con la IA adentro del loop. Sobre esa premisa, el libro dedica un capítulo a cada una de las ocho disciplinas que tenés que traer a la mesa (fundamentos sólidos, programación asistida por IA, visión de diseño de sistemas, profundidad para depurar, disciplina de testing, criterio de code review, entendimiento del producto y responsabilidad sobre los resultados) y muestra, en cada una, dónde la IA falla sola y qué aporta tu juicio para que no falle. No es teoría: cada disciplina baja a tierra con escenarios concretos, y al final tenés un kit operativo (los errores más caros con su versión corregida, plantillas de prompts, checklists para antes de promptear y antes de mergear, casos reales de antes y después, y un manual de una página) para tener al lado mientras trabajás. Para ingenieros que están empezando y quieren que la IA les multiplique el valor en lugar de volverlos prescindibles.

SOLIDITY: Escribí, testeá y desplegá smart contracts que guardan dinero real sin perderlo en el camino

Este libro te enseña a escribir Solidity como lo escribe la gente que guarda dinero real en la cadena: asumiendo que todo contrato es adversarial, que toda llamada externa es una trampa, y que toda línea queda desplegada para siempre. Arranca desde el contrato como una máquina de estados y construye el modelo que de verdad necesitás, cuánto cuestan en serio el storage y la memoria, en qué se diferencian las primitivas de dinero (payable, transfer, send, call) y cuál deja fondos atrapados, por qué la reentrada es el bug que sigue vaciando protocolos y cómo el patrón checks-effects-interactions lo frena, y el catálogo de formas en que se quedan con un contrato: control de acceso que olvidaste, phishing con tx.origin, desborde de enteros, valores de retorno sin chequear, manipulación de oráculos. Después construye la disciplina alrededor del código: testear un contrato contra un adversario con Foundry, medir y recortar el gas, emitir eventos en los que el mundo fuera de la cadena pueda confiar, desplegar y verificar para que la gente pueda leer lo que está confiando, y los patrones de upgrade que te dejan arreglar un error sin meter una puerta trasera. Los ejemplos son contratos reales que de verdad desplegarías, revisados por las formas específicas en que salen mal. Para ingenieros que van a desplegar un contrato que guarda fondos y quieren ser los que desplegaron el que no vaciaron.

ZK: Entendé qué es de verdad una prueba de conocimiento cero y cómo verificar una on chain

Este libro construye el modelo de trabajo de las pruebas de conocimiento cero que un ingeniero necesita para usarlas, no el plan de estudios completo de criptografía. Arranca desde qué es de verdad una prueba, las tres propiedades que importan (completitud, solidez, conocimiento cero), y recorre el puente que la mayoría de las explicaciones se saltea: de una prueba interactiva donde un probador y un verificador conversan, a una no interactiva que podés publicar en la cadena, vía el truco de Fiat-Shamir. Desde ahí construye las piezas que de verdad tocás: cómo un cómputo se convierte en un circuito aritmético y un sistema de restricciones, los tradeoffs honestos entre SNARKs y STARKs (tamaño de la prueba, costo de verificación, trusted setup, post-cuántico), qué es la ceremonia de trusted setup y qué se rompe si estuvo arreglada, y cómo los compromisos y las pruebas de Merkle te dejan probar pertenencia sin revelar el conjunto. Después se pone concreto: escribir un circuito chico, verificar una prueba en la cadena y cuánto cuesta eso en gas, y las aplicaciones reales, los ZK-rollups que escalan una blockchain probando miles de transacciones a la vez, y los sistemas de privacidad para pagos e identidad. El objetivo es el criterio: saber cuándo una prueba de conocimiento cero es la herramienta correcta, qué garantiza, y qué pagás por ella. Para ingenieros que quieren entender ZK lo suficiente para construir con eso y para marcar el humo.

ANVIL: Desarrollá blockchain en tu máquina, forkeá mainnet y testeá los contratos como si fueras el atacante

Este libro te enseña a usar una blockchain local como tu banco de pruebas, para que el contrato que guarda fondos se cruce con cada falla en tu terminal en vez de en producción. Se centra en Anvil, el nodo local del toolkit Foundry, y construye desde lo básico, levantar una cadena, cuentas fondeadas, bloques instantáneos, hasta las técnicas que de verdad encuentran bugs. Vas a forkear mainnet para que tus tests corran contra los protocolos desplegados reales con los que tu contrato habla, usar cheatcodes para hacerte pasar por cualquier dirección, fijar balances y saltar el reloj más allá de una fecha límite, y manipular bloques y tiempo para testear lógica que recién se dispara meses después. Después se pone adversarial: simular un ataque localmente, reproducir el estado exacto donde pasó un exploit, y trazar una transacción que falla para ver dónde se rompió de verdad. La segunda mitad es disciplina, escribir tests de integración basados en fork que cazan lo que los unitarios no ven, scriptear despliegues repetibles, y enganchar todo en CI para que cada push corra contra una cadena forkeada. Los ejemplos son sesiones de testing reales contra contratos reales. Para ingenieros que quieren la confianza que da haber roto ya su contrato mil veces en local antes de que nadie más pudiera intentarlo.

AUDITORÍA: Recuperá tus tardes y dejá de ser el cuello de botella del merge, con el código sano sin leer cada pull request

Este libro le da al tech lead sobrecargado una salida de la trampa de la revisión. Arranca desde la aritmética incómoda: cuanto más custodiás personalmente cada merge, más lento entrega tu equipo y más se te esconden igual los defectos de verdad. Después propone una sola estrategia que el resto del libro desarrolla. Dejá que el equipo mergee rápido, y en vez de inspeccionar cada cambio, inspeccioná el código entero de forma periódica, con un puñado de chequeos de alta señal que te dicen si la calidad se sostiene. Vas a aprender a leer la salud de un sistema que no controlás en persona: qué te está diciendo de verdad un repositorio de checks en verde o en rojo sobre la disciplina de la gente que lo escribe, qué revela el modelo de datos sobre si lo están diseñando o lo dejaron a la deriva, qué dice la forma de las dependencias sobre dónde la arquitectura se está desarmando callada, y dónde viven los riesgos que nunca aparecen en un diff, en seguridad, performance, observabilidad y quién puede tocar producción. Cada lente es una auditoría periódica, planteada para que sepas qué mirar, cómo se ve un resultado sano y de qué te está avisando uno malo, sin volverte otra vez la persona que tiene que mirar todo. Cierra con cómo elegir qué auditar y cada cuánto, y cómo hacer estos chequeos lo bastante baratos como para correrlos para siempre, así dejás de ser el bombero parado frente al botón de merge y te volvés la persona que construyó el sistema que se mantiene sano solo. Para el líder que quiere que su equipo entregue rápido y se mantenga sano, y quiere dejar de ser la razón por la que solo puede una de las dos.

DEFI: Construí protocolos de finanzas descentralizadas: AMMs, pools de préstamo, yield y staking, sin que se te vayan los fondos de los usuarios

Este libro te enseña a construir finanzas descentralizadas como lo construyen los equipos que corren protocolos con TVL real: asumiendo que todo precio se puede mover, que todo depósito se puede retirar en el peor momento, y que toda integración es un contrato que te va a llamar de vuelta a mitad de transacción. Arranca desde la idea de los money legos y la composabilidad, después construye un automated market maker desde la fórmula de producto constante para arriba, así entendés el slippage y el impermanent loss como cosas que podés calcular y no como palabras. De ahí construye un mercado de préstamos: el colateral, el health factor que decide quién está a salvo, la liquidación que mantiene solvente al sistema, y el modelo de tasa de interés que le pone precio a pedir prestado. Cubre los agregadores de yield y los vaults, el staking y la contabilidad de recompensas, y las dos cosas que en silencio deciden si un protocolo sobrevive: de dónde salen tus precios y qué le deja hacer con ellos a un atacante un flash loan por una sola transacción. Cierra con la disciplina que separa a una demo de un despliegue, testear tu protocolo contra liquidez real con un fork de mainnet, y desplegarlo y actualizarlo sin regalarte una puerta trasera. El ejemplo que corre a lo largo del libro es un protocolo chico, construido y atacado a lo largo de los capítulos. Para ingenieros que van a poner un protocolo en la cadena y quieren ser el equipo cuyo pool no quedó vacío.

SECURITY: Aprendé a asegurar smart contracts: conocé los exploits clásicos y auditá un protocolo antes de que maneje millones

Este libro te enseña a leer un smart contract como lo lee un auditor: asumiendo que ya está roto y que tu trabajo es encontrar dónde, antes de que alguien con un bot y un fork de mainnet lo encuentre por vos. Sigue a un protocolo a lo largo de una revisión completa y lo vacía, de forma segura, una clase de bug por vez, para que aprendas cada exploit viéndolo pasar y después cerrándolo. Vas a ver por qué un contrato se vacía mientras los tests siguen en verde, cómo la reentrada le paga dos veces al atacante, cómo un chequeo de acceso olvidado deja que un desconocido se quede con el contrato, cómo el redondeo y el desborde filtran valor de a un wei, cómo se dobla un precio por un solo bloque y cómo se liquida una posición entera sobre esa mentira, cómo alguien lee tu transacción antes de que aterrice y cobra por reordenarla, y cómo un slot de upgrade o un delegatecall entregan el control sin hacer ruido. Después construye la disciplina que agarra todo esto antes que mainnet: cómo corre de verdad una auditoría, las herramientas que encuentran bugs mientras dormís (análisis estático, fuzzing, testing de invariantes), los patrones que hacen imposibles clases enteras de bug en vez de solo improbables, y cómo es la primera hora de un incidente en vivo cuando la plata ya se está moviendo. Los ejemplos son contratos que de verdad desplegarías, revisados por las formas específicas en que salen mal. Para el ingeniero que va a ser la última persona en leer el código antes de que tenga millones, y quiere ser el revisor que lo agarró.

TOKENIZATION: Aprendé a crear tokens y activos tokenizados: estándares ERC, stablecoins, contratos actualizables y activos del mundo real llevados on chain

Este libro te enseña a construir tokens como los construye la gente que pone valor real detrás: asumiendo que el balance son los ahorros de alguien, que la aprobación va a ser abusada, que el price feed va a mentir, y que el upgrade va a intentar corromper tu storage. Arranca desde qué es de verdad un token, un libro contable compartido con reglas, y construye el modelo que necesitás para sacar uno sin perder plata. Cubre el estándar ERC-20 y sus filos, la carrera entre approve y allowance que ya vació wallets reales y la forma segura de otorgar gasto; ERC-721 y ERC-1155 para activos únicos y mixtos y dónde muerden sus hooks de transferencia; minteo, quema y control de supply en el que una tesorería pueda confiar; los tres diseños de stablecoin, respaldada en fiat, en cripto y algorítmica, y por qué uno de ellos sigue fallando; los patrones de upgrade con proxy y la regla de storage layout que decide si tu próximo deploy arregla un bug o crea uno; control de acceso por roles para que ninguna llave sola pueda vaciar el token; tokens permisionados y compliant que pueden congelar, poner en allowlist y responderle a un regulador sin una puerta trasera; tokenizar un activo del mundo real y probar el respaldo; ponerle precio a ese activo con un oráculo que nadie pueda manipular en un solo bloque; y una checklist de despliegue para el día en que el token sale a producción y deja de ser tuyo. El ejemplo que corre a lo largo del libro es un sistema de token que construís capítulo a capítulo, una unidad respaldada en fiat y el oro tokenizado que la respalda, revisado por las formas exactas en que cada pieza lastima a alguien. Para ingenieros que van a sacar un token en el que otra gente confía y quieren ser los que nunca perdieron un centavo por sus decimales, sus aprobaciones ni sus upgrades.

CLAUDE: Dejá de usar Claude Code como un chat que de paso escribe código. Manejalo como el ingeniero agéntico que es, en la terminal, tu editor, el escritorio y el CI, y va a entregarte un día de laburo en una hora sin dejarte un despelote atrás

Esta guía enseña la habilidad duradera detrás de Claude Code: no una lista de features que para el trimestre que viene ya cambiaron, sino cómo manejar una herramienta agéntica de programación para que haga trabajo real en el que podés confiar. Arranca donde está el dolor (el día que te salvó y el día que te quemó) y después recorre los siete movimientos que separan al que opera del que la herramienta pasa por arriba. Vas a configurarla en todos los entornos y saber cuándo ir a la terminal, cuándo a tu editor, cuándo al escritorio y cuándo al navegador. Vas a darle el contexto una vez (un archivo de memoria del proyecto, el repo, un plan acordado antes de que toque el código) para que deje de repreguntar y de adivinar. Vas a manejar una sola tarea como corresponde, leyendo el diff y guiando, para que un buen cambio nunca se vuelva un desparramo malo. Vas a poner los permisos para que vuele en lo seguro y frene en lo peligroso, y decidir qué autoaprobar y qué frenar. Vas a correr trabajo en paralelo (subagentes, varias sesiones, worktrees aislados) sin que las piezas choquen. Vas a extenderla con los conectores, los hooks y los comandos que la hacen encajar en tu stack. Y vas a meterla en el CI para que revise, arregle y responda issues sola mientras no la mirás. Cierra con en quién te convertís cuando todo esto es automático: el ingeniero que entrega más, confía en lo que sale y vale más porque la máquina le multiplica el criterio en vez del despelote. Para el ingeniero que quiere que Claude Code se sienta una palanca, no una tragamonedas.

RESPONSABILIDAD: Volvete el ingeniero al que le confían eso que no puede fallar: te hacés cargo del resultado y no solo de tu ticket, llevás cada problema hasta la causa de fondo y hasta cerrarlo, y no dejás que nada se pierda mientras estás vos a cargo

Este libro trata sobre el único rasgo que decide si te dan el trabajo que importa: la responsabilidad, el hábito de tomar un problema como tuyo y llevarlo hasta un resultado real, no solo hacer tu parte asignada y cruzar los dedos para que el resto salga bien. Arranca desde una verdad incómoda. No tener la culpa no es lo mismo que ser útil, y cerrar tu ticket no es lo mismo que resolver el problema, y toda la industria asciende en silencio por lo segundo mientras le pone nota a los juniors por lo primero. Después te da los hábitos, uno por uno, que separan al ingeniero al que le confían lo importante del que siempre está técnicamente sin culpa. Vas a aprender a decir yo me encargo y referirte al resultado entero, a perseguir una falla hasta su causa real en vez de parchar el síntoma, a arreglar el problema en vez de salir a cazar a quién echarle la culpa, a llevar un tema hasta el final en vez de tirarlo por encima de la pared, a cerrar el círculo para que la gente sepa que de verdad quedó, y a hacerte cargo del seguimiento aburrido y de la grieta que no es trabajo de nadie, incluida la falla que es tuya para arreglar y aprender. Cada hábito viene con un ejercicio que podés hacer esta semana y una imagen clara de cómo se ve cuando está bien, contado a través del arco de un ingeniero que va del que señalaba culpables al que le entregan lo que no puede fallar. Cierra con lo que cambia cuando los problemas dejan de escaparse por las grietas porque son tuyos: te volvés la persona que ascienden, a la que le pagan más, y a la que le confían el trabajo que decide todo. Para el ingeniero cansado de hacer su parte y ver a otro llevarse el crédito por ser dueño del resultado.