--- title: "ShipReal: De vibe coder a ingeniero de verdad" description: "Tu AI escribió la app. Nadie escribió la parte que la mantiene en pie. Este curso de 20 horas cierra esa brecha." canonical: "https://shipreal.dev/es" last-updated: "2026-08-31" --- # De vibe coder a ingeniero de verdad > Tu AI escribió la app. Nadie escribió la parte que la mantiene en pie. Este curso de 20 horas cierra esa brecha. Narración en inglés, subtítulos en español. **38 módulos, postmortems reales, ejercicios prácticos y tests autoevaluados.** [YouTube](https://www.youtube.com/watch?v=fyHbx9de3GI&list=PLFEcqBh9-Xwo) · [Teachable](https://shipreal.teachable.com/courses/course/lectures/66619411) ## Contenido del curso ### Introducción Tu mapa del curso completo: qué aporta cada módulo a fondo y cómo se apoyan entre sí las once partes. - **Introducción: el camino por delante** (13 capítulos, ~25 min): El mapa sobre la mesa: los 38 módulos, qué aporta cada inmersión a fondo y a qué módulo saltar cuando algo se rompe. ### Parte 1: El cambio de mentalidad Recablea cómo piensas el software que funciona: sistemas, estado y compromisos. La capa de criterio que la AI no puede darte. - **La ilusión del 'funciona'** (12 capítulos, ~28 min): El ciclo de vida de la petición, los entornos y el iceberg de producción: por qué 'funciona en mi portátil' no significa casi nada. - **Pensar en sistemas y estado** (12 capítulos, ~29 min): Estado, efectos secundarios e idempotencia: por qué 'vuelve a ejecutarlo' a veces empeora las cosas. - **Decisiones, complejidad y abstracción** (14 capítulos, ~36 min): Compromisos, YAGNI y cuándo una abstracción paga el alquiler: las decisiones de criterio que la AI no puede tomar por ti. ### Parte 2: Los cimientos del desarrollador El oficio diario: Git como herramienta para pensar, un flujo de trabajo nativo de AI, runtimes, algoritmos, arquitectura de frontend y el campo de minas de las dependencias. - **Control de versiones para pensar** (13 capítulos, ~33 min): Git más allá de commit y push: estrategia de ramas, bisect y blame como arqueología. - **El flujo de ingeniería nativo de AI** (13 capítulos, ~31 min): El prompting como escritura de especificaciones, revisar código que no escribiste y los guardarraíles que hacen segura la velocidad de la AI. - **Cómo se ejecuta el código: la capa del runtime** (13 capítulos, ~33 min): Procesos, memoria y el event loop: por qué Node se bloquea y por qué importa el GIL de Python. - **Pensamiento algorítmico: complejidad y estructuras de datos** (13 capítulos, ~27 min): Intuición de Big-O y arrays vs maps vs árboles: cuando N al cuadrado te mata en silencio con 10.000 usuarios. - **Arquitectura frontend: lo que la AI te construye (y lo que hace mal)** (13 capítulos, ~35 min): Modelos de renderizado, gestión de estado y las partes de tu frontend que la AI monta mal. - **Gestión de dependencias: el campo de minas oculto** (12 capítulos, ~31 min): Lockfiles, las mentiras del semver y ataques a la cadena de suministro: la historia de left-pad y cómo no protagonizar la secuela. ### Parte 3: La capa de datos Las bases de datos como modelos mentales: tablas e índices antes que consultas, SQL sin miedo y migraciones que no tiran producción. - **Fundamentos de bases de datos: pensar en datos** (13 capítulos, ~33 min): Pensar en tablas, índices y constraints antes de escribir una sola consulta. - **SQL y pensamiento de consultas** (13 capítulos, ~33 min): Joins sin miedo, planes de consulta que de verdad puedes leer y las consultas que se derriten a escala. - **Datos a escala: mutaciones, migraciones y más allá** (13 capítulos, ~34 min): Mutaciones, migraciones y backfills que no se llevan producción por delante. ### Parte 4: Redes y contratos Cómo se hablan los sistemas: las APIs como contratos, la cadena de DNS a HTTP en la que vive cada petición y patrones en tiempo real. - **El diseño de APIs como contratos** (13 capítulos, ~35 min): Pensar en REST vs RPC, versionar y evolucionar APIs sin romper a quienes dependen de ellas. - **Fundamentos de redes** (12 capítulos, ~33 min): DNS, TCP, TLS, HTTP: la cadena en la que cada petición vive o muere. - **Patrones en tiempo real y por eventos** (12 capítulos, ~33 min): WebSockets, server-sent events y flujos guiados por eventos: para cuando el polling deja de bastar. ### Parte 5: Fortificación Que sobreviva al contacto con la realidad: seguridad por defecto, manejo de errores resiliente, tests que compran confianza y observabilidad que responde a qué se rompió a las 3 de la madrugada. - **Seguridad por defecto** (12 capítulos, ~35 min): Los riesgos principales de OWASP, inyección y fallos de auth: los ataques que te encuentran a ti, no al revés. - **Manejo de errores y resiliencia** (12 capítulos, ~32 min): Timeouts, reintentos con backoff y circuit breakers: fallar con elegancia en vez de a gritos. - **Testing: confianza, no cobertura** (12 capítulos, ~33 min): Tests que compran confianza en vez de cifras de cobertura: qué probar, qué saltarse y por qué. - **Observabilidad: logs, métricas y trazas** (15 capítulos, ~33 min): Logs, métricas y trazas que responden a qué se rompió a las 3 de la madrugada antes que tus usuarios. ### Parte 6: Infraestructura y despliegue Sobre qué se sostiene tu código: qué resuelven de verdad los contenedores, conceptos de nube que sobreviven a cualquier rediseño de consola y pipelines que bloquean los malos despliegues. - **Contenedores: el porqué, no el cómo** (12 capítulos, ~35 min): Lo que Docker resuelve de verdad: imágenes vs contenedores, y por qué 'funciona en el contenedor' por fin significa algo. - **Infraestructura en la nube: conceptos, no clics de consola** (12 capítulos, ~38 min): El árbol de decisión de los servicios gestionados: conceptos de nube que sobreviven a cualquier rediseño de consola. - **CI/CD: el pipeline que te protege** (12 capítulos, ~33 min): El pipeline que bloquea los malos despliegues antes de que los encuentren tus usuarios. ### Parte 7: Arquitectura y escala Diseñar para crecer: arquitectura monolito primero, colas, caché, perfilar antes de optimizar e intuición de sistemas distribuidos. - **Patrones de arquitectura: monolitos, servicios y el término medio** (13 capítulos, ~34 min): Pensar monolito primero, cuándo los servicios se ganan su complejidad y el término medio que nadie promociona. - **Procesamiento asíncrono y colas** (14 capítulos, ~34 min): Colas de mensajes: por qué todo sistema real tiene una y qué pasa cuando los consumidores se quedan atrás. - **Estrategias de caché** (12 capítulos, ~30 min): Redis, TTLs e invalidación de caché: famosa por ser uno de los dos problemas difíciles de la informática. - **Rendimiento, profiling y escalado** (14 capítulos, ~33 min): Perfila antes de optimizar: encontrar el cuello de botella real en vez del que imaginaste. - **Intuición de sistemas distribuidos** (12 capítulos, ~34 min): Las falacias de la computación distribuida, y la intuición para cazarlas en tu propio diseño. ### Parte 8: La capa de negocio El código que paga las facturas: pagos y cumplimiento, métricas que de verdad predicen ingresos y atribución sin mentirte a ti mismo. - **Pagos, suscripciones y cumplimiento** (12 capítulos, ~34 min): Webhooks de pago que sobreviven a los reintentos, máquinas de estados de suscripción y lo básico de cumplimiento que no puedes saltarte. - **Métricas de negocio y analítica de producto** (13 capítulos, ~35 min): Las métricas que de verdad predicen ingresos, y las de vanidad que no. - **Adquisición de usuarios, anuncios y atribución** (13 capítulos, ~36 min): UTMs, ventanas de atribución y matemáticas de anuncios sin mentirte a ti mismo. ### Parte 9: Productos con AI Entregar inteligencia con responsabilidad: cómo aprenden los modelos, embeddings y RAG, y funcionalidades de AI en producción con evals y presupuestos de coste. - **Fundamentos de machine learning: cómo aprenden los modelos** (12 capítulos, ~33 min): Cómo aprenden los modelos en realidad: lo justo para que no te engañen ni demos ni vendedores. - **Añadir inteligencia a tu app** (13 capítulos, ~33 min): Embeddings, RAG y elegir el modelo adecuado para el trabajo en vez del más ruidoso. - **Construir funcionalidades de AI para producción** (12 capítulos, ~33 min): Evals, presupuestos de coste y latencia, y funcionalidades con LLM que sobreviven a usuarios reales. ### Parte 10: Oficio y dominio de producción Los hábitos senior: debugging guiado por hipótesis y la checklist de salida a producción que separa un lanzamiento de una apuesta. - **El debugging como disciplina** (12 capítulos, ~35 min): Debugging guiado por hipótesis: reproducir, aislar, demostrar, no prints y rezar. - **Preparación para producción y operaciones continuas** (14 capítulos, ~37 min): La checklist de salida a producción, la respuesta a incidentes y el ritmo de operaciones que empieza tras el lanzamiento. ### Parte 11: El salto al móvil En el móvil cambia todo: datos offline-first, redes que desaparecen a mitad de petición y trenes de release en las app stores. - **Modelos mentales específicos del móvil** (13 capítulos, ~33 min): Por qué el móvil no es una web pequeña: ciclos de vida, permisos y el sistema operativo como casero estricto. - **Datos y redes en móvil** (12 capítulos, ~37 min): Datos offline-first, conflictos de sincronización y redes que desaparecen a mitad de petición. - **Release y distribución en móvil** (12 capítulos, ~30 min): La revisión de las app stores, trenes de release y por qué un binario no admite hotfix. ### Despedida: La despedida El cierre del curso: qué cambió en tu forma de pensar y la única cosa que hacer mientras aún está fresca. - **La despedida: ahora entrega algo que aguante** (7 capítulos, ~12 min): Qué cambió en tu forma de pensar, la única cosa que hacer esta semana y cómo conservar el criterio que acabas de construir. ## Preguntas frecuentes ### ¿Para quién es este curso? Desarrolladores que aprendieron construyendo, no estudiando. Pones apps en producción con herramientas de AI a diario (Copilot, Claude, ChatGPT) y vas más rápido que nunca. Pero hay una brecha entre "funciona" y "es ingeniería", y la notas cuando algo se rompe a las 3 de la madrugada o cuando un dev senior te pregunta "¿por qué lo hiciste así?" No eres principiante. Sabes escribir código, pero no siempre puedes explicar qué pasa después de pulsar Enter. Esa es exactamente la brecha que cierra este curso. ### ¿Qué me enseña que no pueda conseguir con un prompt? Criterio. La AI escribe ya el 80% de tu código; el 20% que importa es la arquitectura, el manejo de errores, el modelo de seguridad y el diseño del sistema. Ese 20% exige entender compromisos, contexto y consecuencias, que es justo lo que la AI no puede hacer por ti. Cada módulo toma algo que ya "sabes" (bases de datos, APIs, despliegues) y te enseña lo que te falta: el ciclo de vida de una petición, los planes de consulta, las tormentas de reintentos, la invalidación de caché, la checklist de salida a producción. ### ¿Necesito un título en CS o un stack concreto? No hace falta ningún título. El curso está pensado para quienes se lo saltaron, o lo tienen y han olvidado casi todo. Va primero al concepto: los ejemplos usan herramientas conocidas como PostgreSQL, Redis, Docker y Stripe, pero cada módulo enseña el modelo mental, no a pulsar botones de un proveedor, así que sirve para cualquier stack con el que entregues. ### ¿Qué son los postmortems y los ejercicios? Cada módulo de Complete disecciona un desastre de ingeniería real y documentado: empresa real, fecha real, causa raíz real y qué lo habría evitado. Después, el ejercicio aplica el módulo a tu propio proyecto en producción, no a un repo de juguete, de modo que cada módulo termina con tu sistema real un poco más preparado para producción que antes. ### ¿Cuánto tiempo me llevará? Complete son 38 módulos lectivos de 25 a 40 minutos cada uno, más los ejercicios, y cierra con una breve despedida. Calcula unas 20 horas de vídeo, y más o menos el doble con el trabajo práctico. Está organizado en once partes independientes, así que también puedes ir directo a la parte que ahora mismo está ardiendo: ¿despliegues rotos? Parte 6. ¿Consulta lenta? Parte 3. ### ¿Obtengo un certificado? ¡Sí! Y se gana, no se regala por mirar vídeos: el certificado de graduación de ShipReal, emitido por Teachable. Cada módulo cierra con un test autoevaluado de 10 preguntas y una pregunta abierta, y el certificado llega cuando las has trabajado todas. ### ¿Puede mi empresa comprarlo para todo el equipo? Sí. Las plazas se venden directamente, al precio por plaza de los planes para equipos de arriba, en una sola factura, y se mueven con el equipo cuando la gente entra y sale. Cada ingeniero recibe el curso Complete, trabajado sobre su propio proyecto y no sobre un sandbox compartido. A partir de 20 plazas, o cuando necesites un PO, single sign-on con SAML u OIDC, o los módulos dentro de tu propio LMS como paquetes SCORM o xAPI o vía LTI, en Cornerstone, Workday, Moodle o lo que use tu organización, escríbeme y lo dimensionamos juntos. ### ¿Y si no es para mí? Empieza por los resúmenes gratuitos en YouTube: te dirán rápido si el curso habla tu idioma. Más allá de eso, la garantía de la tabla de precios es toda la respuesta, y la mecánica para reclamarla está en la política de reembolsos. ### ¿En qué idiomas está disponible? Por ahora la narración es solo en inglés. Complete en Teachable incluye subtítulos en inglés, francés, alemán, italiano, español y hebreo. Pronto habrá más idiomas. ## Legal [Privacy Policy](https://shipreal.dev/privacy) · [Terms of Service](https://shipreal.dev/terms) · [Refund Policy](https://shipreal.dev/refunds)