Ingeniero Frontend: Construí las interfaces de los productos que la gente usa de verdad. Ese trabajo te consigue empleo, clientes y el sueldo que valés.

Description

REACT: Volvete el que revisa el React que te escribe un agente de IA y caza lo que se le escapó antes de que llegue a producción, el criterio de senior que ninguna herramienta te da

Este libro te entrena para ser el revisor de React vibe-codeado, no para memorizar la API. Arranca desde una premisa distinta a la de cualquier otro libro de React: el agente escribe los componentes, y tu palanca es entender qué hace ese código en realidad para poder revisarlo con el criterio que el type checker no tiene. Vas a aprender qué es en realidad un render y cuándo React re-renderiza, cómo se guardan los hooks y por qué existen sus reglas, qué controla de verdad el array de dependencias de un effect, por qué el Context hace re-renderizar a los consumidores, qué tiene que ver la igualdad referencial con la performance, y qué te da en realidad el React concurrente, y vas a aprender todo eso como lo necesita un revisor: leyendo componentes reales 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 pieza de estado, a revisar un componente como la capa de datos o el formulario, a revisar cómo encaja toda la app y dónde se va a romper con datos y carga reales. Acá casi no hay ejercicios de sintaxis y sí mucho sobre flujo de datos, comportamiento de re-render, modos de falla y las formas específicas en que el React de un agente sale mal. Para ingenieros que van a vibe-codear en React de todas formas y quieren ser los que cazan lo que se le escapó al modelo.

IA NATIVA UX: Diseñá los productos de IA en los que la gente de verdad confía, y volvete el que sabe cómo mientras todos los demás pegan un chat al costado

Esta guía te muestra por qué pegar una ventana de chat encima de una app existente falla por construcción, y cómo rediseñar el software desde los primeros principios alrededor de la intención del usuario en lugar de la navegación. Vas a ver cómo colapsar un panel de administración de 700 parámetros en un control por lenguaje natural sin perder precisión, cómo pasar de dibujar pantallas a diseñar los puntos de decisión donde el usuario revisa y corrige el plan antes de que se ejecute, y cómo decidir cuándo la IA solo sugiere, cuándo pide permiso y cuándo corre sola. La estrategia no es una lista de tendencias, es el orden en que tomás cada decisión de diseño cuando el software deja de ser navegable: cómo se expresa y se resuelve la intención, cómo mostrar qué hace la IA sin abrumar a nadie, cómo diseñar la confianza cuando el sistema actúa por el usuario, y qué queda cuando los menús, los formularios y los dashboards desaparecen. Cada capítulo ataca el punto exacto donde un producto con IA pegada se siente roto, y te deja la decisión de diseño ya tomada en vez del problema abierto. Para quienes construyen producto y necesitan salir de la cárcel del cuadro de chat.

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.

TYPESCRIPT: La habilidad en TypeScript que hace que cambiar el código sea seguro en vez de dar miedo, para que entregues más rápido y te confíen la base de código

Esta guía te muestra cómo usar TypeScript para que el compilador trabaje para vos, atrapando el bug antes de que se entregue y volviendo un refactor seguro en lugar de aterrador. Arranca desde qué es de verdad un tipo (un conjunto de valores permitidos) y construye el modelo que hace que el resto encaje: cómo la inferencia te salva de anotar todo, cómo modelar datos con uniones, objetos y tipos literales para que los estados ilegales no se puedan representar, cómo el narrowing deja que el compilador siga tu lógica, cómo los generics te dejan escribir algo reutilizable sin perder seguridad de tipos, y cómo tipar las partes que de verdad muerden (async, errores, datos externos en el borde, y la elección entre any y unknown). Después se pone práctica: tipar una aplicación real de punta a punta, configurar tsconfig con los flags estrictos que valen la pena, y leer un error de tipos confuso para encontrar qué te está diciendo en realidad. El libro no te tira una referencia de cada utility type. Te enseña a describir tus datos con precisión, a confiar en el compilador, y a escribir tipos que un compañero pueda leer. Para desarrolladores que ya escriben JavaScript y quieren la red de seguridad que hace que un codebase sea más fácil de cambiar.

TAILWIND: La habilidad en Tailwind para entregar interfaces prolijas en una fracción del tiempo, sin el quilombo que suele dejar la velocidad

Esta guía te muestra cómo usar Tailwind CSS para estilar interfaces rápido sin el quilombo que lo rápido suele traer. Arranca desde por qué existe el utility-first y el problema que resuelve (la hoja de estilo descontrolada y los nombres que nunca te salen), y después construye las partes que lo mantienen mantenible a escala: cómo las clases utilitarias mapean a CSS real para que siempre sepas qué estás escribiendo, cómo los variants responsive y de estado (hover, focus, dark mode, breakpoints) reemplazan la mayoría de las media queries a mano, cómo el theme de la config guarda tus tokens de diseño para que los colores y el espaciado se mantengan consistentes, cómo extraer un botón o una card en un componente real en el momento en que copiás un string de clases dos veces, y cómo componer un sistema de diseño chico y coherente en vez de una pila de estilos sueltos. También cubre las partes que la gente hace mal: cuándo recurrir a un valor arbitrario y cuándo eso es un olor, cómo mantener el markup legible, y cómo encaja Tailwind con un framework de componentes como React. El libro no lista cada utilidad. Te enseña a apoyarte en los tokens de diseño, a componentizar antes de repetir, y a entregar una UI que se mantiene consistente mientras crece. Para desarrolladores que quieren estilar rápido y aun así entregar algo limpio.

JAVASCRIPT: Volvete el que revisa el JavaScript de navegador que te escribe un agente de IA y caza lo que se le escapó antes de que llegue a producción, la habilidad que te vuelve difícil de reemplazar

Este libro te entrena para ser el revisor de JavaScript vibe-codeado, no para memorizar la sintaxis. Arranca desde una premisa que la mayoría de los libros de JavaScript se saltea: el agente escribe el código, y tu palanca es entender qué hace ese código de verdad cuando el navegador lo corre, para poder revisarlo con el criterio que un linter no tiene. Vas a aprender qué es en realidad un valor y dónde la coerción convierte un tipo en otro a tus espaldas, por qué dos cosas que parecen iguales no lo son, cómo el scope y los closures capturan variables y cómo esa captura queda vieja, a qué apunta this y cuándo se reasigna en silencio, cómo los objetos comparten referencias así que un cambio se propaga a tres, por qué el event loop corre tu código en un orden que no escribiste, cómo las promesas y async/await esconden un camino rechazado, y dónde una pestaña del navegador pierde memoria hasta que se arrastra. Vas a aprender todo eso como lo necesita un revisor, leyendo código real que el agente generaría para Ledger, un pequeño rastreador de gastos en el navegador al que volvemos en cada capítulo, y decidiendo qué está bien, qué es plausible pero peligroso y qué hay que devolver. La progresión va de un solo valor y cómo se compara, a una función y qué capturó, al runtime asincrónico entero y dónde se va a romper con datos y usuarios reales. Acá casi no hay ejercicios de sintaxis y sí mucho sobre comportamiento, timing, modos de falla y las formas específicas en que el JavaScript de un agente sale mal. Para ingenieros que van a vibe-codear en JavaScript de todas formas y quieren ser los que cazan lo que se le escapó al modelo.

NEXT.JS: Volvete el ingeniero que revisa el Next.js que te escribe un agente de IA y caza lo que se le escapó antes de mandarlo a producción, la habilidad que se paga como senior

Este libro te entrena para ser el revisor de Next.js vibe-codeado, no para memorizar el framework. Arranca desde la premisa a la que vuelve cada capítulo: el agente escribe las rutas, los layouts y los server components, y tu palanca es entender qué hace ese código en realidad en el servidor, en el cache y en el navegador, para poder revisarlo con el criterio que el build no tiene. Vas a aprender dónde termina el servidor y empieza el cliente y por qué un solo `”use client”` mal puesto cambia todo lo que hay debajo, qué puede alcanzar un server component que un client component no, cómo decide Next cuándo se arma una página y cuándo se cachea, qué controlan de verdad `revalidate` y las opciones de cache de `fetch`, cómo llega una mutación desde un botón hasta tu base de datos a través de una Server Action y dónde hay que custodiar ese camino, y por qué un boundary de `loading` o de `error` que falta convierte a un solo widget lento o roto en una pantalla en blanco. Lo vas a aprender como lo necesita un revisor: leyendo el código que el agente generaría para un proyecto real y decidiendo qué está bien, qué es plausible pero peligroso y qué hay que devolver. Acá casi no hay ejercicios de sintaxis y sí mucho sobre cómo se comporta Next.js bajo datos reales, latencia real y usuarios reales. Para ingenieros que van a vibe-codear en Next.js de todas formas y quieren ser los que cazan lo que el modelo mandó a producción.

CSS: Entendé CSS para interfaces de verdad: la cascada, el modelo de caja y el layout responsive con flexbox y grid

Este libro te entrena para ser el revisor de CSS vibe-codeado, no para memorizar propiedades. Arranca desde una premisa distinta a la de cualquier otro libro de CSS: el agente escribe los estilos, y tu palanca es entender qué hace ese CSS en realidad para poder revisarlo con el criterio que ningún linter tiene. Vas a aprender cómo la cascada decide qué regla gana y por qué las peleas de especificidad terminan en !important, qué cuenta el modelo de caja como ancho y por qué el padding te sorprende, cómo el flujo normal, flexbox y grid colocan cada uno una caja y dónde el agente elige el equivocado, qué le hacen el posicionamiento y los stacking contexts a un menú que desaparece detrás del header, por qué un píxel fijo se rompe en la próxima pantalla mientras las unidades relativas se doblan, cómo un layout que se ve bien en un viewport se desarma en otro, por qué una tipografía que todavía no cargó corre toda la página, y qué hace que un color sea legible y no apenas visible. Vas a aprender todo eso como lo necesita un revisor: leyendo hojas de estilo reales que el agente generaría para una sola interfaz que nos acompaña, un dashboard llamado Kanso, y decidiendo qué está bien, qué es plausible pero frágil y qué hay que devolver. La progresión va de juzgar una sola regla, a juzgar un componente como la card o la toolbar, a juzgar cómo se comporta todo un layout responsive con contenido largo, pantallas chicas y usuarios que no ven como vos. Acá casi no hay ejercicios de sintaxis y sí mucho sobre cómo se comporta CSS en realidad, dónde se rompe y las formas específicas en que el estilo de un agente sale mal. Para ingenieros que van a vibe-codear su CSS de todas formas y quieren ser los que cazan lo que se le escapó al modelo.

STATE: El criterio en React que te vuelve el que firma cómo se modela el estado de una app, no las cinco librerías que configurás a mano una sola vez

Este libro te entrena para ser el revisor del estado vibe-codeado, no para memorizar Redux o Zustand. La premisa es distinta a la de cualquier otro libro de manejo de estado: el agente escribe los reducers, los providers y los selectors, y tu palanca es saber si el estado que hay debajo está bien modelado, un juicio que ningún type checker hace. Vas a aprender la distinción en la que se resuelven casi todos los bugs de estado, cache del servidor contra estado del cliente, y por qué sincronizar el primero dentro del segundo a mano es el error que le manda datos viejos a la gente. Vas a aprender por qué Context re-renderiza a todos los consumers cuando la referencia de su value se mueve, cuándo una pieza de estado se ganó un store externo y cuándo Context o un useState levantado siempre alcanzó, cómo modelan de verdad un store Redux Toolkit y Zustand y dónde encaja cada uno, por qué un selector que devuelve una referencia nueva re-renderiza para siempre, por qué el dato derivado va en el render y no en el store, cómo normalizar los datos evita que dos pantallas se contradigan, y por qué un formulario es lo último que debería vivir en un store global. Aprendés todo eso como lo necesita un revisor: leyendo el código de store que un agente generaría contra un proyecto que corre a lo largo del libro, un cliente de presupuestos que llamamos Ledger, y decidiendo qué está bien, qué es plausible pero caro y qué hay que devolver. Acá casi no hay setup de librerías y sí mucho sobre dónde va el estado, qué tiene que guardar y las formas específicas en que el manejo de estado de un agente sale mal en silencio. Para ingenieros que van a vibe-codear el store de todas formas y quieren ser los que cazan el cache viejo antes que la gente.

RENDERIZACIÓN: Hacé que tus apps de React vuelen y volvete al que el equipo llama cuando la app está lenta, la habilidad que separa a un senior de un staff

Este libro te enseña a hacer React rápido como lo hace un staff: entendiendo el motor, midiendo antes de tocar nada y arreglando la única cosa que en realidad estaba lenta. Arranca donde nace de verdad la velocidad, qué pasa entre que llamás a setState y el navegador pinta un pixel, la fase de render y la de commit, Fiber y por qué React puede pausar y descartar trabajo. De ahí aprendés a leer el Profiler y contestar por qué se renderizó este componente, a ubicar el estado para que un cambio no se propague por todo el árbol, a memoizar solo donde rinde y a reconocer el caso mucho más común en que no hace nada, a mantener la interfaz fluida durante actualizaciones caras con el React concurrente, a partir el código y leer tu propio bundle, a renderizar una lista de diez mil filas dibujando cuarenta, y a distinguir cuándo React va rápido pero lo lento es el propio pintado del navegador. Cada capítulo trabaja una misma app de ejemplo, un tablero llamado Ledger, y la lleva de arrastrarse a instantánea, y cada arreglo se mide, nunca se adivina. Acá casi no hay trivia de la API y sí mucho sobre cómo funciona el render de verdad, adónde se va el tiempo y cómo probar que un cambio hizo la app más rápida en vez de solo sentir que sí. Para el desarrollador que quiere ser al que el equipo llama cuando la app está lenta.

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.

DEMOS: Mostrale tu trabajo a la gente que lo paga y que quede. Contá una historia en vez de pasear feature por feature, cortá el desastre de la demo en vivo antes de que pase y salí de la reunión con el sí, el presupuesto y el crédito

Este libro le enseña al ingeniero a mostrar su propio trabajo para que de verdad impacte en la gente que decide. Arranca desde la cuenta que nadie dice en voz alta: un gran trabajo que se demuestra mal se muere en la reunión, y un trabajo mediocre con una demo afilada se lleva el presupuesto, así que la demo no es un trámite después del trabajo de verdad, es donde el trabajo de verdad vive o muere. Después te da una forma repetible de armar una. Vas a aprender a entrar a la reunión sabiendo ya la única cosa que querés sacar de ahí y quién tiene que decir que sí para dártela. Vas a aprender a abrir con el problema y con lo que está en juego en vez de con la herramienta, así una persona que nunca vio tu sistema siente el dolor en el primer minuto y se engancha. Vas a aprender a guionar la única historia que cuenta la demo, el camino feliz que los lleva del antes al después, para que sea un relato que siguen y no un catálogo que aguantan. Vas a aprender a preparar una demo en vivo para que no te pueda humillar: qué dejar cargado, qué simular con honestidad, qué grabar de respaldo, para que la cosa que siempre se rompe no se rompa frente a la gente a la que más necesitabas impresionar. Vas a aprender a leer la sala mientras hablás y a sobrevivir la pregunta difícil, esa que antes te liquidaba, para que un escéptico en primera fila se vuelva la razón por la que la sala te cree. Y vas a aprender a plantar el antes y el después para que sientan el cambio en la panza, y después cerrar pidiendo en voz alta la cosa exacta que fuiste a buscar, porque una demo que no pide se lleva un aplauso y ninguna decisión. Cada paso es un movimiento en una secuencia, planteado para que sepas qué hacer, cómo se ve una sala que te está comprando y cómo se ve una sala que estás perdiendo, a tiempo para arreglarlo. Cierra con el ingeniero en el que te convertís cuando podés mostrar tu trabajo: ese que ponen frente al cliente, al directorio, a la plata, ese que se lleva el crédito y el ascenso porque la sala por fin vio lo que construiste. Para el ingeniero cansado de hacer el mejor trabajo y llevarse el menor crédito, porque el que sabe demostrarlo se lleva la sala.

OFICIO: Escribí código que sobreviva a su propio segundo año y volvete el ingeniero al que el equipo le confía los sistemas que importan, el criterio que separa a alguien que programa de alguien a quien le pagan por diseñar

Este libro te enseña el oficio que hay debajo del código: cómo escribir software que se mantiene legible, cambiable y confiable mucho después de salir a producción, para que te vuelvas el ingeniero al que el equipo le confía los sistemas que importan. Trabaja una sola base de código en marcha, Tessera, un servicio de pedidos y facturación que arrancó limpio y se pudrió, y la reconstruye hasta devolverle la salud mientras te enseña las movidas que mantienen el código blando: nombres que dicen la verdad, funciones que hacen una sola cosa nombrable, comentarios que no mienten, matar la duplicación que arreglás en cuatro lugares y te comés el quinto, y refactorizar seguro detrás de tests para cambiar la forma sin romper el comportamiento. Se apoya abiertamente en el canon del campo, Clean Code de Robert Martin, The Pragmatic Programmer de Hunt y Thomas, y Refactoring de Martin Fowler, y convierte sus principios en hábitos que aplicás en tu próximo pull request: manejar el acoplamiento para que un cambio deje de tocar cinco archivos, manejar la falla para que no se vuelva un misterio a las 3 de la mañana, y tomar deuda técnica a propósito en vez de que ella te tome a vos. Para el desarrollador cansado de temerle a su propio código que quiere escribir del tipo que otros heredan con gusto.

ENTREVISTAS: Convertí la habilidad que ya tenés en la oferta, y dejá de ver cómo contratan a ingenieros peores que vos solo porque entrevistan mejor

Esta guía trata la entrevista como lo que es, una habilidad aparte que se aprende, y te entrena para convertir la capacidad que ya tenés en ofertas. Sigue a una candidata a través de un loop real y enseña cada etapa: qué mide la entrevista de verdad (no es coding puro), el puñado de patrones detrás de la mayoría de las preguntas de estructuras de datos, cómo pensar en voz alta para que el entrevistador siga tu mente en lugar de adivinarla, cómo correr una ronda de coding desde clarificar el problema hasta nombrar los casos borde, y un framework de system design que encaja en casi cualquier consigna para que dejes de improvisar. Se apoya en los estándares del rubro, Cracking the Coding Interview de Gayle Laakmann McDowell y System Design Interview de Alex Xu, y suma lo que ellos saltean: estimación a ojo sin pánico, respuestas de comportamiento que aterrizan sin sonar recitadas, el take-home que te lleva a la ronda siguiente, entrevistar cruzando una pantalla y una frontera, y negociar la oferta sin perderla. Para el ingeniero fuerte cansado de que lo pasen por arriba en la entrevista y que quiere el puesto, el nivel y el sueldo que su habilidad ya se ganó.