Ingeniero IA: Hoy la IA es la habilidad más escasa y mejor paga de la ingeniería. Dejá de entregar features y empezá a diseñar los sistemas que las sostienen, esos que aguantan usuarios de verdad.

Description

ASISTENTES DE IA: Dejá de copiar y pegar de un chat: armá tu propio agente versionado y trabajá como un líder técnico que delega, no como un tipeador

Esta guía te lleva de usar la IA como un chat al final del día a operar tu propio agente versionado que escribe código por vos, abre PRs, hace grooming de tickets, manda daily updates y, con el tiempo, corre solo de forma segura. La mayoría usa la IA para preguntar, copiar, pegar y olvidar, y el resultado es código inconsistente, contexto que se pierde entre sesiones y cero apalancamiento. La estrategia del libro es tratar al agente como un repositorio que versionás igual que cualquier proyecto: un puñado de archivos que definen quién es, qué sabe hacer y con qué herramientas, que vas afilando hasta que el propio agente empieza a escribirse a sí mismo. Sobre esa misma base construís tres niveles que reusan los mismos archivos: un asistente local conectado a tus editores y CLIs, un agente autónomo que decide solo cuándo correr, y un sistema de producción donde (a diferencia de los atajos populares) las credenciales nunca tocan el modelo. En el camino vas a entender por qué esos atajos son inseguros y cómo evitar el error que la mayoría no ve hasta que es tarde. Para programadores que ya escriben código todos los días y quieren dejar de tipear para empezar a coordinar.

AGENTES EN PRODUCCIÓN: Volvete el ingeniero de IA por el que las empresas pelean, el que convierte una demo que impresiona en el producto del que un negocio depende todos los días.

Esta guía te muestra cómo llevar agentes de IA de un prototipo que anda en tu máquina a un sistema en producción que sirve tráfico real, rápido y sin que los costos se disparen. Armar el agente es la parte fácil; ponerlo a servir a miles de usuarios con baja latencia, alta confiabilidad y costos controlados es otro juego, y es justo donde la mayoría de los proyectos se traba. La estrategia del libro no es darte recetas sueltas, sino el orden en que hay que tomar cada decisión del salto a producción: cómo estructurar el sistema para que aguante carga real, cómo orquestar las llamadas a herramientas sin que se vuelvan un caos, cómo ver qué pasa por dentro antes de que falle, cómo frenar los costos antes de que exploten, y cómo blindarlo con guardrails, CI/CD y escalado en la nube. Cada capítulo ataca el punto exacto donde un agente prometedor se cae en producción, y te deja la decisión tomada en vez del problema abierto. Para ingenieros que ya construyeron agentes de IA y ahora necesitan entregarlos en producción de forma confiable y sostenible.

MCP: Volvete el revisor que con su visto bueno garantiza que un server de MCP que escribió una IA es de verdad seguro, el criterio en el que tu equipo confía.

Este libro te entrena para ser el revisor de MCP vibe-codeado, no para memorizar un SDK. Arranca desde una premisa distinta a la de cualquier otra guía de protocolo: el agente escribe el server y la integración, y tu palanca es entender qué hace en realidad MCP para poder revisarlo con el criterio que el protocolo no tiene. Vas a aprender la arquitectura host-cliente-servidor y la capa JSON-RPC que tiene debajo, qué garantizan de verdad el handshake de initialize y la negociación de capacidades, en qué se diferencian los transportes y dónde stdio se vuelve una superficie de ataque de red, por qué el nombre y la descripción de un tool son en realidad un prompt que lee el modelo, por qué el resultado de un tool es un vector de inyección, cuándo conviene un resource o un prompt en vez de un tool, y qué significan sampling, elicitation y el consentimiento para la confianza, y vas a aprender todo eso como lo necesita un revisor: leyendo el código real de server y de cliente que generaría un agente, contra un único proyecto en ejecución, decidiendo qué está bien, qué es plausible pero peligroso y qué hay que devolver. Vas a construir el server Quill MCP con FastMCP y verlo montado sobre una app FastAPI común y escrito contra el SDK de bajo nivel, y después integrarlo con Claude Code, un agente de LangChain y un agente de Google ADK como ejemplos, porque MCP es un protocolo, no un solo framework. La progresión va de revisar un solo tool, a revisar un server entero y su superficie de seguridad, a revisar la integración completa de host más agente y cómo se despliega. Acá casi no hay tutorial de copiar y pegar y sí mucho sobre el contrato del protocolo, la superficie de contexto que ve el modelo, la seguridad y el consentimiento, y las formas específicas en que el MCP de un agente sale mal. Para ingenieros que van a vibe-codear servers y agentes de todas formas y quieren ser los que cazan lo que se le escapó al modelo.

ALUCINACIONES: Construí agentes de IA en los que la gente puede confiar de verdad, que nunca inventan una respuesta, y volvete el ingeniero que entrega IA confiable.

Esta guía te muestra cómo diseñar agentes de IA que resisten la información fabricada, con defensas que viven en la arquitectura y no en la buena voluntad del modelo. Un modelo no miente: hace lo que fue entrenado para hacer (producir texto plausible) y, cuando le falta un dato, igual responde con el mismo tono seguro, inventando hechos, identificadores o acciones que nunca ejecutó. Pedirle en el prompt que ‘no alucine’ es una garantía blanda. La estrategia del libro toma prestado un principio que las organizaciones serias usan hace siglos para que nadie reporte información falsa y lo traduce a arquitectura de agentes: separar a quien hace el trabajo de quien lo verifica, exigir evidencia para cada afirmación, y diseñar las herramientas y los prompts para que fabricar sea difícil en lugar de fácil. No es teoría: salís con patrones concretos, reglas listas para pegar en tus instrucciones y una implementación de referencia en Python. Para ingenieros que construyen agentes con acceso a herramientas y datos reales y necesitan que solo digan lo que pueden probar.

HITL: Volvete el ingeniero en el que las empresas confían para darle poder real a un agente, porque el tuyo nunca actúa sin un sí humano.

Esta guía te muestra cómo construir agentes que exigen aprobación humana antes de ejecutar acciones irreversibles, con una garantía real (no una promesa del prompt) de que esa aprobación es genuina, está acotada a una sola acción y no se puede reusar ni falsificar. La estrategia es mover la autorización del lugar donde casi todos la ponen (las instrucciones del modelo, que se olvidan, se racionalizan o se alucinan) al único lugar donde no se puede esquivar: el código que ejecuta la herramienta. Vas a aprender a decidir qué herramientas merecen una barrera y cuáles no, cómo lograr que el humano apruebe en contexto y dentro de la misma conversación sin frenar al agente en todo lo demás, y cómo el agente retoma la tarea solo cuando hay un sí real. El cómo exacto de esa garantía lo construís pieza por pieza, con una implementación de referencia en Python lista para portar a cualquier plataforma. Para ingenieros que ya construyeron agentes y ahora necesitan ponerles límites en los que se pueda confiar.

VISIÓN ARTIFICIAL: Volvete el ingeniero que con su palabra deja pasar o frena cualquier pipeline de visión hecho con IA, en quien confían el modelo cuando tiene que funcionar de verdad.

Este libro te entrena para ser el revisor de un pipeline de computer vision vibe-codeado, no para memorizar una librería. Arranca desde una premisa distinta a la de casi cualquier libro de visión: un backbone preentrenado y un agente van a escribir el modelo y el training loop, y tu palanca es entender cómo funciona la visión lo suficiente como para juzgar la arquitectura, la evaluación y el despliegue con tres preguntas que el agente nunca hace. Vas a aprender cómo una máquina convierte pixeles en features, qué calcula de verdad una convolución, y por qué las CNN, los Vision Transformers y los modelos de difusión le sirven cada uno a un problema distinto, para que puedas darte cuenta de cuándo la arquitectura más hypeada es la equivocada. Vas a recorrer las tres tareas centrales, clasificación, detección y segmentación, y a leer qué significa de verdad la salida de cada modelo y qué métrica esconde la falla que tus usuarios sí van a sentir. Y como el puente de la investigación a producción es donde se traban casi todos los proyectos, la mitad del libro es datos y despliegue: armar un dataset y un split que no mienta, augmentation y anotación que escalen, y la compresión, la inferencia en el dispositivo y el monitoreo de drift que deciden si la cosa sobrevive el contacto con imágenes reales. Cada capítulo diseña una pieza real de un sistema que funciona, muestra la versión buena contra la mala que produciría un agente, y es honesto sobre lo que cuesta en latencia, tamaño y etiquetado. Para ingenieros que van a construir con modelos de visión de todas formas y quieren ser los que cazan el diseño que estaba por salir roto a producción.

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.

VERTEX AI: Volvete la persona a la que el equipo le pregunta qué servicio de Vertex usar, la que lee el mapa y nunca paga de más

Esta guía es un mapa de trabajo de Vertex AI, la parte de Google Cloud donde construís, entrenás, servís y corrés IA, desde los modelos fundacionales del Model Garden hasta la plataforma de agentes, el stack de MLOps, la capa de serving y los servicios especializados para búsqueda, visión, voz y documentos. Vertex creció hasta tener docenas de productos, y la dificultad real no es aprender ninguno en particular sino saber a cuál recurrir, cómo se conectan, y cuál podés ignorar tranquilo para el trabajo que tenés enfrente. El libro no narra cada botón. Recorre la plataforma en el orden en que de verdad la adoptás: dónde probar un modelo antes de comprometerte, las tres formas de construir un agente y cuándo encaja cada una, la plomería que vuelve a los agentes con estado y gobernados, las herramientas de laboratorio y linaje que mantienen el entrenamiento reproducible, cómo entrenar solo cuando un modelo fundacional no alcanza, cómo servir predicciones a escala y buscar vectores rápido, cómo vigilar un modelo en producción, y qué te compran los servicios especializados frente a construirlo vos mismo. Cada capítulo te deja en condiciones de elegir, no solo nombrar, el servicio que encaja. Para ingenieros y arquitectos que ya saben escribir el código y ahora necesitan navegar la plataforma sin comprar de más ni perderse.

INGENIERÍA DE PROMPTS: Volvete el ingeniero que convierte un modelo impredecible en algo que una empresa puede lanzar de verdad y sobre lo que apuesta su producto

Esta guía trata al prompting como ingeniería, no como conjuro, para que puedas hacer que un modelo haga trabajo real de forma confiable en vez de impresionante una sola vez. Arranca desde cómo lee de verdad un modelo un prompt (predice el próximo token a partir de todo lo que hay en el contexto, así que la posición, la estructura y lo que dejaste ambiguo importan) y construye las técnicas que aguantan: escribir una instrucción que el modelo no pueda malinterpretar, darle un rol y el contexto que necesita, usar ejemplos (few-shot) para fijar un formato o un comportamiento, y pedir razonamiento paso a paso donde de verdad ayuda y saltearlo donde solo quema tokens. Después llega a la parte que separa un demo de un producto: forzar salida estructurada que puedas parsear y validar, descomponer una tarea difícil en una cadena de prompts que puedas testear cada uno, anclar las respuestas en contexto recuperado para que el modelo deje de inventar, y defenderte de la inyección de prompts cuando entra texto del usuario. La segunda mitad es la disciplina que la mayoría de los consejos de prompting se saltea: armar un set de evaluación con las entradas que de verdad rompen tu prompt, medir los cambios en vez de adivinar, versionar los prompts como código, y manejar el costo y la latencia. Los ejemplos son prompts reales para un producto real, mostrados fallando y después arreglados. Para ingenieros que quieren que un modelo haga trabajo confiable, no un truco ingenioso que anda en el demo y falla en la vida real.

RAG: Volvete el ingeniero que construye respuestas de IA en las que un usuario confía de verdad, ancladas en fuentes que puede chequear y no en pura invención

Esta guía te muestra cómo construir generación aumentada por recuperación que da respuestas precisas, ancladas y con citas desde tus propios datos, en vez de un demo que suena bien e inventa. Arranca desde por qué un modelo necesita recuperación y construye el pipeline pieza por pieza: cómo partir los documentos para que un pasaje cargue suficiente contexto para ser útil, qué es de verdad un embedding y cómo la búsqueda vectorial encuentra las piezas relevantes, por qué la búsqueda puramente semántica se pierde términos exactos y cómo la búsqueda híbrida (palabra clave más vector) lo arregla, y cómo el reranking sube los pocos pasajes que de verdad responden la pregunta. Después construye la mitad de generación con honestidad: armar un contexto que entre en el presupuesto sin enterrar la respuesta, pedirle al modelo que responda solo desde el texto recuperado y que diga cuando no puede, agregar citas para que un humano pueda verificar, y detectar cuando la recuperación no trajo nada útil para que no respondas desde el vacío. La segunda mitad es lo que la hace confiable: evaluar la recuperación y las respuestas con un set de prueba real, medir fidelidad y relevancia en vez de impresiones, depurar si una mala respuesta fue una falla de recuperación o de generación, y controlar el costo y la latencia. Los ejemplos son una base de conocimiento real conectada a un asistente real, mostrados fallando y después arreglados. Para ingenieros que necesitan respuestas ancladas en sus propios datos en las que un usuario, y un regulador, puedan confiar.

AGENTES DE IA: Volvete el ingeniero en quien confían para aprobar o frenar el código de un agente de IA, el criterio que ningún modelo te da

Este libro te entrena para ser el revisor de código de agente vibe-codeado, no para memorizar la API de un framework. Arranca desde una premisa distinta a la de cualquier otro libro de agentes: el modelo escribe el agente, y tu palanca es entender qué hace ese código en realidad en cada turno para poder revisarlo con el criterio que el type checker no tiene. Vas a aprender qué es el loop del agente y dónde falla en terminar, cómo una tool call se vuelve una acción y qué hay que chequear antes de que se dispare, por qué la salida estructurada necesita un schema y no un parseo esperanzado, cómo se mueve el estado entre pasos y dónde te lo mutan por atrás, cómo funcionan las rutas de la orquestación y cómo los retries, los guardrails y el traspaso a humanos evitan que un turno malo se vuelva un resultado malo, y vas a aprender todo eso como lo necesita un revisor: leyendo código de agente real que el modelo generaría y decidiendo qué está bien, qué es plausible pero peligroso y qué hay que devolver. La progresión va de revisar un solo turno, a revisar las tools y el estado a su alrededor, a revisar cómo se sostiene todo un sistema multiagente y dónde se rompe con tráfico real, no determinismo y costo. Acá casi no hay un tour del framework y sí mucho sobre control de flujo, modos de falla, seguridad y las formas específicas en que el código de agente de un agente sale mal. Para ingenieros que van a vibe-codear agentes de todas formas y quieren ser los que cazan lo que se le escapó al modelo.

AUTOMATIZACIÓN CON IA: Convertite en el operador cuya automatización corre sola mientras dormís, y recuperá tus horas en vez de vivir cuidando un flujo que se rompe

Este libro te entrena para ser el revisor de la automatización construida con IA, no para memorizar una sola herramienta. Arranca desde una premisa que la mayoría de los cursos de automatización se saltea: el agente (y el lienzo no-code) pueden construir el flujo más rápido de lo que vos lo describís, y tu palanca es saber si ese flujo va a sobrevivir a datos reales y sucios corriendo sin supervisión. Vas a aprender a mapear un proceso de negocio antes de automatizarlo, a elegir un trigger que se dispare con el evento exacto, a conectar sistemas por APIs y webhooks sin confiar en cada campo, a tratar un paso de IA como una entrada no confiable que hay que verificar antes de que escriba nada, a enriquecer datos sin inventarlos, a hacer un flujo idempotente para que un re-run nunca cobre dos veces, a construir caminos de error y escalamiento humano para las acciones de alto riesgo, a reconocer los flujos que deberías negarte a automatizar, y a probar y monitorear una automatización en marcha para que una falla silenciosa aparezca antes que un cliente. El ejemplo que corre a lo largo del libro es Beacon, un pipeline de enriquecimiento y ruteo de leads para una empresa chica, y cada capítulo revisa una pieza de él tal como la construiría un agente y decide qué es seguro, qué es plausible pero peligroso y qué hay que devolver. Poco de esto se trata de hacer clic en el botón correcto. La mayor parte se trata del criterio que evita que una automatización sin supervisión te cueste en silencio plata, datos y confianza. Para el operador que va a automatizar con IA de todas formas y quiere ser el que caza lo que se le escapó al agente.

TESTING DE IA: Volvete el ingeniero que da la cara por la calidad de un sistema de IA, el que ataja una alucinación antes de que le llegue a un usuario

Este libro te enseña a testear sistemas de IA como lo exige la nueva ola de roles de QA, construyendo la suite de evaluación que decide si un sistema LLM o RAG es lo bastante bueno para salir. Arranca desde la ruptura central: un modelo es no determinista y probabilístico, así que testearlo es medir una distribución de calidad, no afirmar una salida exacta, y muestra qué medir en cambio. Va a fondo en RAG, la arquitectura detrás de la mayoría de la IA en producción, y qué significa correcto para ella: precisión de recuperación (volvió el contexto correcto, medido contra un set etiquetado), fidelidad o grounding (la respuesta está de verdad respaldada por el texto recuperado, no inventada), relevancia de la respuesta, y la falla de la cita alucinada donde un modelo cita una fuente que no dice lo que afirma. Cubre las técnicas que hacen testeable un sistema probabilístico, un set de evaluación armado con preguntas reales y respuestas de referencia, scoring con LLM-as-judge (y cómo mantener honesto al juez), evaluación humana basada en rúbricas, y los frameworks que usa el campo (RAGAS, TruLens, y suites custom). Después construye el resto de la superficie de validación que estos sistemas necesitan: regression testing para que un cambio de prompt o de modelo no pueda bajar la calidad en silencio, calibración del score de confianza y drift del peso de fuentes, testing de inyección de prompts y seguridad, y chequeos de RBAC y control de acceso para que un tenant no pueda recuperar los datos de otro. Cierra con la decisión de go/no-go: convertir la evaluación en un reporte de precisión y evidencia de test sobre la que un equipo puede salir, y enganchar las evals en CI para que la calidad se controle, no se espere. Los ejemplos son un asistente RAG real, mostrado pasando un test ingenuo mientras alucina en silencio, y después puesto a prueba contra una eval que lo ataja. Para ingenieros que quieren ser los que de verdad pueden probar que un sistema de IA funciona.

TOKENS: Volvete el ingeniero que hace que la IA se pague sola y mantiene la factura plana aunque explote el tráfico

Esta guía te muestra cómo hacer que un agente de IA sea barato a propósito, para que sobreviva al contacto con el tráfico real en lugar de fundir al proyecto que lo construyó. Armar un agente que responde bien es la parte fácil; mantenerlo preciso mientras la factura de tokens se mantiene plana a medida que crece el volumen es el problema de ingeniería del que nadie te avisa, y es justo donde se traban los sistemas prometedores. El libro no te da trucos sueltos. Te da el orden en que hay que tomar cada decisión de costo: cómo leer el equilibrio entre precisión y gasto en lugar de perseguir solo la precisión, cómo fijar un presupuesto y un umbral de suficiente antes de construir, cómo la forma de tu orquestación mueve la factura, cómo recortar el contexto, cachear y escalar de modelos baratos a caros solo cuando hace falta, cómo predecir el costo antes de que una tarea corra, y cómo evitar que los reintentos y los usuarios maliciosos conviertan tu agente en una canilla abierta. Cada capítulo ataca el punto exacto donde el costo de un agente se dispara en producción y te deja la decisión tomada en vez del problema abierto. Para ingenieros y arquitectos que ya saben construir el agente y ahora necesitan que se pague solo.

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.

MACHINE LEARNING: Entendé el machine learning que hay debajo de la IA que ya usás, y armá modelos que aguanten en producción, el cimiento escaso que se paga y que llamar a una API nunca te enseñó

Este libro enseña el cimiento de machine learning que hay debajo de la IA que ya usás, para que dejes de tratar a los modelos como magia y empieces a armar unos que puedas explicar, evaluar y mandar a producción. Construye un sistema entero de punta a punta, un predictor de churn para un producto SaaS, y lo usa para enseñar lo que de verdad importa: qué hace el machine learning que las reglas no pueden, por qué el problema de datos decide todo antes que el modelo, cómo convertir la realidad desprolija en features que un modelo pueda aprender, y cómo entrenar un primer modelo que le gane a una moneda al aire. Se apoya en los estándares del campo, el Hands-On Machine Learning de Aurelien Geron y el Designing Machine Learning Systems de Chip Huyen, y se niega a quedarse en la notebook: leer las métricas de evaluación que mienten y las que no, por qué un modelo la rompe en el training set y falla en el mundo real, los algoritmos clásicos que todavía ganan en producción, servir predicciones bajo latencia, cazar el drift que hace a un modelo acertado en junio y equivocado en diciembre, y diseñar todo el sistema de ML alrededor del modelo en vez de solo el modelo. Para el desarrollador que se cansó de llamar caja negra a la IA y quiere la habilidad escasa y mejor paga de entenderla.