Cursos en esta ruta
Guía de OOP y Modelado de Datos en Python
Un diccionario suelto con las llaves correctas puede parecerse a un objeto, pero no protege sus invariantes, no expone comportamiento y se rompe en silencio cuando alguien le mete un valor inválido. Esta guía enseña a diseñar un modelo de objetos limpio, correcto y "pythónico" partiendo de ese problema real. Trabajas modelando un solo dominio de principio a fin —Reservo, un sistema de reservas de salas de coworking— y lo construyes con clases desde cero: primero el paso de datos sueltos a un objeto que junta datos y comportamiento, después encapsulación con propiedades que validan invariantes, `@dataclass` para modelar datos inmutables sin código repetitivo, composición para armar el grafo de objetos del dominio, herencia y polimorfismo para los distintos tipos de socio, protocolos y clases abstractas para diseñar contra interfaces en vez de contra implementaciones concretas, y los métodos dunder que hacen que un objeto se sienta nativo de Python (comparación, orden, iteración, context managers). Todo el código se ejecuta de verdad con Python 3.14 y se verifica contra números de ancla del dominio (una reserva de 3 horas en la sala Focus cuesta 7500 centavos, con 20% de descuento para el tier pro). El proyecto final modela el dominio Reservo completo con las ocho piezas integradas y una demo ejecutable.
64 lecciones
Guía del Toolchain Moderno de Python
El toolchain de un proyecto Python —qué intérprete lo corre, dónde viven las dependencias, quién revisa el estilo y los tipos, quién construye y publica el paquete— se decide una sola vez y se paga todos los días. Esta guía te lleva a operar ese toolchain con las herramientas que la industria adoptó en 2026: `uv` para intérpretes, entornos y dependencias con lockfile reproducible; Ruff como linter y formateador único que reemplaza a flake8, isort, pyupgrade y black; un verificador de tipos (mypy, pyright o ty) integrado a `pyproject.toml`; automatización con hooks de pre-commit y GitHub Actions; y empaquetado y publicación en PyPI con trusted publishing. El diferencial no es la lista de comandos, sino el criterio: cada herramienta se presenta con su argumento a favor y su objeción más seria, incluyendo cuándo NO conviene adoptarla y cómo evaluar la salud de gobernanza de un proyecto open source antes de apostarle tu stack. Todo el recorrido construye un solo proyecto —`pkgpeek`, una CLI que consulta PyPI— que termina publicado desde CI con nueve entregables verificables y un documento de decisiones que defiende cada elección.
48 lecciones
Guía de Tipado y Pydantic
Una anotación de tipo en Python es una etiqueta, no un candado: el intérprete la lee, la guarda y sigue ejecutando sin comprobar nada. Esta guía corrige ese malentendido de raíz y construye, sobre él, un sistema completo de tipado estático y validación en runtime con Pydantic v2. Trabajas sobre un solo caso de estudio realista —Cosecha, una plataforma que conecta productores agrícolas con restaurantes, donde todos los datos vienen de afuera (un CSV desordenado por productor, un webhook de pagos, una API de clima, un formulario web) y ninguno es confiable— y lo llevas de cuarenta funciones sin anotar a un sistema donde lo inválido no puede existir. Aprendes a instalar y leer un verificador de tipos (mypy) sin frustrarte con los primeros 300 errores, a describir la forma real de tus datos con el vocabulario completo de `typing`, a convertir esas descripciones en validación de verdad con Pydantic, a expresar reglas de negocio como código en vez de `if` dispersos, y a diseñar fronteras donde el dato se valida una sola vez para que el resto del sistema deje de programar a la defensiva. La guía cierra con los casos difíciles del mundo real —librerías sin tipos, JSON de forma variable, configuración por variables de entorno, migración de Pydantic v1 a v2— y con el criterio explícito para saber cuándo el tipado estorba y cuándo ceder con una razón escrita.
64 lecciones
Construir con LLMs desde Código
Integra un LLM en un producto real desde código, no desde un notebook de experimentación. Esta guía trabaja directo contra el SDK del proveedor —a propósito, para que entiendas qué abstrae un framework antes de adoptarlo— a lo largo de ocho módulos: tratar al LLM como una dependencia más de tu software (no determinista, cobrada por token), construir tu primera integración seria con un cliente propio, mantener los prompts como código versionado, obtener salidas estructuradas y validadas en vez de parsear texto libre, dar herramientas al modelo con tool calling controlado por tu código, exponer respuestas en streaming, endurecer la integración contra fallas reales de un proveedor, y evaluar y lanzar con una suite de evals que te dice si un cambio mejoró o empeoró el sistema. El proyecto final es un servicio de triage de tickets de soporte listo para producción: clasificación validada con Pydantic, respuesta en streaming, herramientas reales, reintentos, caché, control de costo y evals corriendo en CI.
64 lecciones
Guía de Depuración y Diagnóstico
Toma un fallo desconocido —un traceback de treinta líneas, un resultado silenciosamente incorrecto, una regresión enterrada en doscientos commits o un test que falla uno de cada treinta días— y apréndelo a reproducir, acorralar hasta la línea exacta y explicar con evidencia, antes de pedirle nada a un modelo; y cuando se lo pides, aprende a verificar si la respuesta es correcta. Los seis módulos avanzan de leer el fallo (lo que un traceback ya te está diciendo) al método que va del síntoma a la causa raíz, al depurador para detener el programa y mirar por dentro, al logging para diagnosticar lo que ya pasó, a la bisección para acorralar regresiones y fallos intermitentes, y cierran con la IA en el ciclo: usarla después de entender el error, no en su lugar. El proyecto final es un dossier de depuración sobre un repositorio con cinco fallos de naturaleza distinta —incluida una regresión que exige `git bisect run`— resueltos con protocolo, evidencia y test de regresión.
48 lecciones
Guía para Trabajar con Agentes de Código
Aprende a dirigir agentes de código como oficio profesional, no como improvisación. Esta guía cubre las seis piezas que separan el uso amateur del profesional: el oficio de dirigir en vez de escribir directamente, el desarrollo dirigido por especificación (spec-driven), la ingeniería del harness —el entorno, el contexto y los permisos que dejas listos para que el agente se verifique solo—, la verificación y revisión de lo que el agente genera, el presupuesto y control de costo en tokens y tiempo, y el gobierno del código asistido por IA dentro de un equipo. Al terminar sabes escribir especificaciones ejecutables, preparar un repositorio "agent-ready", revisar —no aceptar— lo que un agente produce, controlar cuánto gastas en tokens y en atención humana, y redactar el playbook que gobierna cómo tu equipo trabaja con agentes.
48 lecciones
Guía de PostgreSQL y SQLAlchemy
Aprende PostgreSQL desde la instalación hasta queries optimizadas, modela tus datos con SQLAlchemy ORM, gestiona el schema con Alembic, e integra todo de forma async con FastAPI. Esta guía reemplaza los datos en memoria por persistencia real y profesional, exactamente como se usa en producción. Diseñada para desarrolladores que ya construyeron APIs con FastAPI y necesitan dar el siguiente paso: una base de datos relacional bien diseñada que escale.
48 lecciones
Guía de Git y GitHub
Domina el control de versiones con Git y el desarrollo colaborativo con GitHub, desde tu primer commit hasta pipelines de CI/CD en producción. Esta guía te lleva paso a paso por todo lo que necesitas para trabajar profesionalmente con Git: flujo local, branches, resolución de conflictos, Pull Requests, workflows de equipo, automatización con hooks y GitHub Actions, y recuperación de errores. Diseñada para developers de cualquier lenguaje que quieren dejar de tenerle miedo a Git y empezar a usarlo con confianza en equipos reales.
104 lecciones
Guía de Seguridad en Código Generado por IA
El 45% del código generado por AI tiene fallas de seguridad (Veracode 2025). Java: 72% failure rate. JavaScript: 43%. Python: 38%. XSS: 86% del código AI falla en protección adecuada. Y los modelos más grandes NO generan código más seguro. Esta guía te enseña a detectar, prevenir y corregir vulnerabilidades en código producido por cualquier herramienta AI. OWASP Top 10 aplicado a código AI, patrones de vulnerabilidad desglosados por lenguaje, herramientas de detección automática (static analysis, dependency scanning, secrets detection), checklist de security review para todo output AI, técnicas de hardening (sanitización, validación, encoding), y secrets management — qué nunca pasarle al agente. 6 módulos, 3 phases, y un proyecto de security audit completo que produce un reporte profesional. Guía 100% reutilizable — aplica a cualquier herramienta AI, no solo a Claude Code.
32 lecciones
Guía de Async y Concurrencia en Python
La concurrencia no acelera el trabajo: elimina el tiempo en que tu programa no estaba trabajando. Esa distinción entre esperar (red, disco, un servicio externo) y calcular (procesador al 100%) es la que decide toda esta guía y la que casi nadie tiene clara antes de empezarla. Trabajas sobre un solo caso realista —Faro, un servicio que vigila el precio de 300 productos en 12 tiendas en línea y hoy tarda 40 minutos porque hace todo de forma secuencial— y lo llevas, módulo a módulo, a un recolector concurrente de unos 2 minutos. Aprendes el modelo mental real de `async`/`await` (por qué `async def` por sí solo no acelera nada), a lanzar y controlar cientos de tareas con límites de cortesía para no tumbar al otro lado, a manejar fallas parciales y cancelación, a usar hilos cuando el código bloqueante es ajeno y no se puede reescribir (como una librería de terceros), y a usar procesos cuando el trabajo es cómputo puro que ningún `async` ni ningún hilo va a acelerar por el GIL. La guía cierra con los problemas que solo aparecen en producción con volumen y tiempo real —memoria, conexiones, apagado ordenado, depuración de bugs intermitentes— y con un proyecto final donde defiendes con números qué herramienta usaste en cada capa y qué dejaste deliberadamente secuencial.
64 lecciones
Guía de Empaquetado y Herramientas CLI
Un script que "funciona en mi máquina" y un paquete instalable que otra persona puede usar son dos cosas muy distintas, y esta guía te lleva de uno al otro paso a paso. Trabajas empaquetando un solo caso realista —`reservo`, un sistema de reservas de salas de coworking cuyo modelo de objetos ya existe— y lo conviertes en una librería instalable con una herramienta de línea de comandos propia. Aprendes qué es un módulo y un paquete, cómo funciona `import` y el `sys.path`, el estándar moderno `pyproject.toml` (PEP 621) y cómo construir un wheel y un sdist reales con `uv build`, a aislar el proyecto en entornos virtuales y manejar dependencias con `pip` y `uv`, a construir una CLI completa con `argparse` (sin dependencias externas), a exponerla como comando instalado con un entry point en `[project.scripts]`, a estructurar un paquete real con submódulos, imports relativos y una API pública deliberada, y a configurar el toolchain de calidad (`ruff`, `mypy`, `pytest`, `pre-commit`). Todo lo ejecutable se corre de verdad —el comando `reservo price --tier basic --hours 3` imprime `7500` desde tu terminal—; lo único que se enseña como contenido sin ejecutar es la publicación en PyPI, porque es una acción pública e irreversible. El proyecto final integra las siete piezas en un paquete completo, construido, instalado y corriendo de punta a punta.
64 lecciones
Guía de Performance y Profiling
La intuición sobre qué hace lento a un programa casi siempre miente, y optimizar sin medir es la forma más común de perder tiempo arreglando la parte que no era el problema. Esta guía enseña el proceso completo de optimización con la única regla que importa: medir primero, cambiar después. Trabajas sobre un solo caso realista —Nómada, una herramienta de línea de comandos que procesa registros de viaje de una flota de vehículos y tarda cuatro minutos en generar un reporte mensual— y lo llevas a los pocos segundos usando el método real: cronometrar con el reloj correcto, perfilar con `cProfile` para encontrar dónde se va el tiempo de verdad (que casi nunca es donde el equipo cree), medir el costo de memoria, elegir la estructura de datos correcta para el problema, y aplicar la optimización específica que corresponde a cada cuello de botella real. La guía también enseña a reconocer cuándo Python puro ya no alcanza y hay que empujar el trabajo a código vectorizado, y cómo documentar y proteger una optimización para que no se pierda en el próximo refactor. El proyecto final exige el reporte honesto de qué cambió, cuánto ganó cada cambio y qué se decidió NO optimizar y por qué.
64 lecciones