Upload folder using huggingface_hub

.gitattributes

@@ -563,3 +563,48 @@ Curso[[:space:]]de[[:space:]]Inglés[[:space:]]Práctico[[:space:]]sobre[[:space
 Curso[[:space:]]de[[:space:]]Inglés[[:space:]]Práctico[[:space:]]sobre[[:space:]]las[[:space:]]Partes[[:space:]]del[[:space:]]Cuerpo/04-Actividad[[:space:]]física[[:space:]]y[[:space:]]Deportes[[:space:]]en[[:space:]]Inglés/05-worksheet-whose-got-the-ball_04d38340-043f-4ea5-8ec6-f48570ef1840.pdf filter=lfs diff=lfs merge=lfs -text
 Curso[[:space:]]de[[:space:]]Inglés[[:space:]]Práctico[[:space:]]sobre[[:space:]]las[[:space:]]Partes[[:space:]]del[[:space:]]Cuerpo/05-Continua[[:space:]]practicando/01-Recapitulación[[:space:]]de[[:space:]]Verbos[[:space:]]Sensoriales[[:space:]]y[[:space:]]Actividades[[:space:]]Físicas.mp4 filter=lfs diff=lfs merge=lfs -text
 Curso[[:space:]]de[[:space:]]Inglés[[:space:]]Práctico[[:space:]]sobre[[:space:]]las[[:space:]]Partes[[:space:]]del[[:space:]]Cuerpo/05-Continua[[:space:]]practicando/02-Conclusiones[[:space:]]del[[:space:]]Taller[[:space:]]de[[:space:]]Inglés[[:space:]]Repaso[[:space:]]y[[:space:]]Siguientes[[:space:]]Pasos.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Claude[[:space:]]Code/01-Módulo[[:space:]]1[[:space:]]DiscoveryAnálisisPlanning/01-Desarrollo[[:space:]]conversacional[[:space:]]con[[:space:]]Claude[[:space:]]Code[[:space:]]para[[:space:]]proyectos[[:space:]]reales.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Claude[[:space:]]Code/01-Módulo[[:space:]]1[[:space:]]DiscoveryAnálisisPlanning/02-Flujo[[:space:]]profesional[[:space:]]para[[:space:]]desarrollar[[:space:]]features[[:space:]]con[[:space:]]Claude[[:space:]]Code.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Claude[[:space:]]Code/01-Módulo[[:space:]]1[[:space:]]DiscoveryAnálisisPlanning/03-Instalación[[:space:]]y[[:space:]]configuración[[:space:]]básica[[:space:]]de[[:space:]]Claude[[:space:]]Code[[:space:]]con[[:space:]]npm.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Claude[[:space:]]Code/01-Módulo[[:space:]]1[[:space:]]DiscoveryAnálisisPlanning/04-Fundamentos[[:space:]]de[[:space:]]Claude[[:space:]]Code[[:space:]]contexto[[:space:]]subagentes[[:space:]]y[[:space:]]herramientas.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Claude[[:space:]]Code/01-Módulo[[:space:]]1[[:space:]]DiscoveryAnálisisPlanning/05-Análisis[[:space:]]de[[:space:]]arquitectura[[:space:]]full[[:space:]]stack[[:space:]]con[[:space:]]Claude[[:space:]]Code.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Claude[[:space:]]Code/01-Módulo[[:space:]]1[[:space:]]DiscoveryAnálisisPlanning/06-Análisis[[:space:]]de[[:space:]]impacto[[:space:]]del[[:space:]]feature[[:space:]]de[[:space:]]ratings[[:space:]]con[[:space:]]Claude[[:space:]]Code.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Claude[[:space:]]Code/01-Módulo[[:space:]]1[[:space:]]DiscoveryAnálisisPlanning/07-Creación[[:space:]]de[[:space:]]subagentes[[:space:]]especializados[[:space:]]en[[:space:]]Claude[[:space:]]Code[[:space:]]para[[:space:]]planificación.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Claude[[:space:]]Code/01-Módulo[[:space:]]1[[:space:]]DiscoveryAnálisisPlanning/08-Actualización[[:space:]]de[[:space:]]Claude[[:space:]]Code[[:space:]]a[[:space:]]versión[[:space:]]20[[:space:]]y[[:space:]]mejoras[[:space:]]de[[:space:]]Sonnet[[:space:]]45.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Claude[[:space:]]Code/01-Módulo[[:space:]]1[[:space:]]DiscoveryAnálisisPlanning/09-Creación[[:space:]]de[[:space:]]subagentes[[:space:]]especializados[[:space:]]en[[:space:]]Claude[[:space:]]Code.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Claude[[:space:]]Code/02-Módulo[[:space:]]2[[:space:]]Implementación[[:space:]]Backend/01-Uso[[:space:]]de[[:space:]]unit[[:space:]]tests[[:space:]]para[[:space:]]migraciones[[:space:]]seguras[[:space:]]de[[:space:]]base[[:space:]]de[[:space:]]datos.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Claude[[:space:]]Code/02-Módulo[[:space:]]2[[:space:]]Implementación[[:space:]]Backend/02-Implementación[[:space:]]de[[:space:]]ratings[[:space:]]en[[:space:]]backend[[:space:]]con[[:space:]]Claude[[:space:]]Code[[:space:]]y[[:space:]]Docker.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Claude[[:space:]]Code/02-Módulo[[:space:]]2[[:space:]]Implementación[[:space:]]Backend/03-Implementación[[:space:]]de[[:space:]]ratings[[:space:]]con[[:space:]]estrellas[[:space:]]en[[:space:]]lista[[:space:]]de[[:space:]]cursos[[:space:]]frontend.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Claude[[:space:]]Code/02-Módulo[[:space:]]2[[:space:]]Implementación[[:space:]]Backend/04-Integración[[:space:]]de[[:space:]]ratings[[:space:]]con[[:space:]]API[[:space:]]usando[[:space:]]Claude[[:space:]]Code.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Claude[[:space:]]Code/03-Módulo[[:space:]]3[[:space:]]Gestión[[:space:]]de[[:space:]]Contexto[[:space:]]y[[:space:]]Comandos/01-Instalación[[:space:]]de[[:space:]]servidores[[:space:]]MCP[[:space:]]en[[:space:]]Claude[[:space:]]Code.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Claude[[:space:]]Code/03-Módulo[[:space:]]3[[:space:]]Gestión[[:space:]]de[[:space:]]Contexto[[:space:]]y[[:space:]]Comandos/02-Control[[:space:]]de[[:space:]]costos[[:space:]]y[[:space:]]modelos[[:space:]]en[[:space:]]Claude[[:space:]]Code.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Claude[[:space:]]Code/03-Módulo[[:space:]]3[[:space:]]Gestión[[:space:]]de[[:space:]]Contexto[[:space:]]y[[:space:]]Comandos/03-Instalación[[:space:]]de[[:space:]]Claude[[:space:]]Code[[:space:]]en[[:space:]]GitHub[[:space:]]con[[:space:]]Actions.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Claude[[:space:]]Code/03-Módulo[[:space:]]3[[:space:]]Gestión[[:space:]]de[[:space:]]Contexto[[:space:]]y[[:space:]]Comandos/04-Integración[[:space:]]de[[:space:]]Claude[[:space:]]Code[[:space:]]en[[:space:]]pull[[:space:]]requests[[:space:]]de[[:space:]]GitHub.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Claude[[:space:]]Code/03-Módulo[[:space:]]3[[:space:]]Gestión[[:space:]]de[[:space:]]Contexto[[:space:]]y[[:space:]]Comandos/05-Desarrollo[[:space:]]conversacional[[:space:]]con[[:space:]]Claude[[:space:]]Code[[:space:]]para[[:space:]]programar[[:space:]]con[[:space:]]contexto.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/01-Módulo[[:space:]]1[[:space:]]conceptos[[:space:]]básicos/01-Estructura[[:space:]]y[[:space:]]reglas[[:space:]]fundamentales[[:space:]]del[[:space:]]álgebra.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/01-Módulo[[:space:]]1[[:space:]]conceptos[[:space:]]básicos/02-Partes[[:space:]]de[[:space:]]una[[:space:]]expresión[[:space:]]algebraica[[:space:]]variables[[:space:]]coeficientes[[:space:]]y[[:space:]]términos.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/01-Módulo[[:space:]]1[[:space:]]conceptos[[:space:]]básicos/03-Leyes[[:space:]]de[[:space:]]los[[:space:]]signos[[:space:]]y[[:space:]]exponentes[[:space:]]en[[:space:]]álgebra[[:space:]]básica.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/01-Módulo[[:space:]]1[[:space:]]conceptos[[:space:]]básicos/03-pdf-leyes-de-los-exponentes_7594d357-af54-4766-9f5f-4f05331f30c3_569f2a2d-f061-4b7d-8343-f72a851364a2.pdf filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/01-Módulo[[:space:]]1[[:space:]]conceptos[[:space:]]básicos/04-Leyes[[:space:]]de[[:space:]]los[[:space:]]radicales[[:space:]]para[[:space:]]simplificar[[:space:]]expresiones[[:space:]]algebraicas.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/01-Módulo[[:space:]]1[[:space:]]conceptos[[:space:]]básicos/04-ley-de-radicales-recurso-1_0f08f8f3-952c-4a21-8bfa-f7e53e7e0452.jpg filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/01-Módulo[[:space:]]1[[:space:]]conceptos[[:space:]]básicos/04-ley-de-radicales-recurso-1_c79bece6-6e8d-4573-a919-aa3883712faf.jpg filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/01-Módulo[[:space:]]1[[:space:]]conceptos[[:space:]]básicos/04-ley-de-radicales-recurso-2_6ac6717a-3ade-44c0-873f-6610d4ba37dd.jpg filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/01-Módulo[[:space:]]1[[:space:]]conceptos[[:space:]]básicos/04-ley-de-radicales-recurso-3_dd9c28b6-8bc8-4466-a810-02a76c628e7f.jpg filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/01-Módulo[[:space:]]1[[:space:]]conceptos[[:space:]]básicos/05-Propiedades[[:space:]]algebraicas[[:space:]]básicas[[:space:]]neutros[[:space:]]inversos[[:space:]]y[[:space:]]distributiva.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/02-Módulo[[:space:]]2[[:space:]]monomios[[:space:]]polinomios[[:space:]]productos[[:space:]]notables[[:space:]]y[[:space:]]factorización/01-Estructura[[:space:]]y[[:space:]]operaciones[[:space:]]básicas[[:space:]]con[[:space:]]monomios.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/02-Módulo[[:space:]]2[[:space:]]monomios[[:space:]]polinomios[[:space:]]productos[[:space:]]notables[[:space:]]y[[:space:]]factorización/02-Clasificación[[:space:]]y[[:space:]]operaciones[[:space:]]básicas[[:space:]]con[[:space:]]polinomios[[:space:]]y[[:space:]]monomios.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/02-Módulo[[:space:]]2[[:space:]]monomios[[:space:]]polinomios[[:space:]]productos[[:space:]]notables[[:space:]]y[[:space:]]factorización/03-Factor[[:space:]]común[[:space:]]en[[:space:]]expresiones[[:space:]]algebraicas.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/02-Módulo[[:space:]]2[[:space:]]monomios[[:space:]]polinomios[[:space:]]productos[[:space:]]notables[[:space:]]y[[:space:]]factorización/04-Factorización[[:space:]]de[[:space:]]cuadrados[[:space:]]y[[:space:]]cubos[[:space:]]de[[:space:]]binomios.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/02-Módulo[[:space:]]2[[:space:]]monomios[[:space:]]polinomios[[:space:]]productos[[:space:]]notables[[:space:]]y[[:space:]]factorización/04-pdf-factorizacion-con-cubos-y-cuadrados_62afd4bf-f02c-44f0-9513-026866038b39.pdf filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/02-Módulo[[:space:]]2[[:space:]]monomios[[:space:]]polinomios[[:space:]]productos[[:space:]]notables[[:space:]]y[[:space:]]factorización/05-Factorización[[:space:]]de[[:space:]]trinomios[[:space:]]cuadrados[[:space:]]perfectos[[:space:]]y[[:space:]]trinomios[[:space:]]generales.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/03-Módulo[[:space:]]3[[:space:]]Ecuaciones[[:space:]]e[[:space:]]inecuaciones/01-Diferencia[[:space:]]entre[[:space:]]expresiones[[:space:]]algebraicas[[:space:]]y[[:space:]]ecuaciones.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/03-Módulo[[:space:]]3[[:space:]]Ecuaciones[[:space:]]e[[:space:]]inecuaciones/02-Desigualdades[[:space:]]símbolos[[:space:]]intervalos[[:space:]]y[[:space:]]operaciones[[:space:]]básicas.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/03-Módulo[[:space:]]3[[:space:]]Ecuaciones[[:space:]]e[[:space:]]inecuaciones/03-Definición[[:space:]]y[[:space:]]resolución[[:space:]]de[[:space:]]ecuaciones[[:space:]]con[[:space:]]valor[[:space:]]absoluto.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/03-Módulo[[:space:]]3[[:space:]]Ecuaciones[[:space:]]e[[:space:]]inecuaciones/04-Funciones[[:space:]]lineales[[:space:]]y[[:space:]]el[[:space:]]plano[[:space:]]cartesiano.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/04-Módulo[[:space:]]4[[:space:]]Sistemas[[:space:]]de[[:space:]]ecuaciones[[:space:]]lineales/01-Tipos[[:space:]]de[[:space:]]sistemas[[:space:]]de[[:space:]]ecuaciones[[:space:]]lineales[[:space:]]y[[:space:]]sus[[:space:]]soluciones.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/04-Módulo[[:space:]]4[[:space:]]Sistemas[[:space:]]de[[:space:]]ecuaciones[[:space:]]lineales/02-Métodos[[:space:]]de[[:space:]]resolución[[:space:]]de[[:space:]]sistemas[[:space:]]de[[:space:]]ecuaciones[[:space:]]lineales.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/04-Módulo[[:space:]]4[[:space:]]Sistemas[[:space:]]de[[:space:]]ecuaciones[[:space:]]lineales/03-Matrices[[:space:]]definición[[:space:]]operaciones[[:space:]]y[[:space:]]cálculo[[:space:]]de[[:space:]]determinantes.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/04-Módulo[[:space:]]4[[:space:]]Sistemas[[:space:]]de[[:space:]]ecuaciones[[:space:]]lineales/04-Métodos[[:space:]]de[[:space:]]Gauss[[:space:]]y[[:space:]]GaussJordan[[:space:]]para[[:space:]]sistemas[[:space:]]de[[:space:]]ecuaciones.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/04-Módulo[[:space:]]4[[:space:]]Sistemas[[:space:]]de[[:space:]]ecuaciones[[:space:]]lineales/05-Resolución[[:space:]]de[[:space:]]sistemas[[:space:]]de[[:space:]]ecuaciones[[:space:]]con[[:space:]]la[[:space:]]regla[[:space:]]de[[:space:]]Cramer.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/05-Módulo[[:space:]]5[[:space:]]función[[:space:]]cuadrática[[:space:]]y[[:space:]]logaritmos/01-Características[[:space:]]y[[:space:]]resolución[[:space:]]de[[:space:]]funciones[[:space:]]cuadráticas.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Álgebra[[:space:]]y[[:space:]]Funciones/06-Módulo[[:space:]]5[[:space:]]Funciones[[:space:]]trascendentales[[:space:]]y[[:space:]]logaritmos/01-Diferencia[[:space:]]entre[[:space:]]funciones[[:space:]]algebraicas[[:space:]]y[[:space:]]trascendentales.mp4 filter=lfs diff=lfs merge=lfs -text

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/01-Desarrollo conversacional con Claude Code para proyectos reales.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c8a4e49d98795269ebd80cd187908ed26652a4986ffe5b25ae3380c628a38954
+size 29140835

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/01-Desarrollo conversacional con Claude Code para proyectos reales.vtt

@@ -0,0 +1,32 @@
+WEBVTT
+
+00:00:00.000 --> 00:00:08.380
+[Cortinilla musical de fondo]. Cada desarrollador conoce el ciclo: abrir el editor, buscar archivos, escribir, romper y arreglar. Una y otra vez. Pero Claude Code lo cambia todo
+
+00:00:08.380 --> 00:00:17.460
+desde la raíz, porque no completa el código por ti. Analiza el proyecto completo, conecta archivos, entiende el contexto y propone soluciones coherentes con la
+
+00:00:17.460 --> 00:00:27.459
+arquitectura existente. No responde órdenes, conversa. No genera líneas, construye contigo. En este curso, no vas a memorizar comandos, vas a aprender a desarrollar conversando,
+
+00:00:27.459 --> 00:00:34.700
+con criterio, con intención y con una inteligencia que entiende tu proyecto de principio a fin. Vas a formar parte del equipo de PlatziFlix, una
+
+00:00:34.700 --> 00:00:42.299
+plataforma de cursos online. ¿Tu tarea? Implementar un sistema de calificación de uno a cinco estrellas para los cursos. Un proyecto real con backend en
+
+00:00:42.299 --> 00:00:51.879
+fase API, frontend en Next.js y base de datos con PostgreSQL. Construyes conversando con Claude, que ejecuta, valida y prueba cada cambio. Optimiza y colabora
+
+00:00:51.879 --> 00:01:02.360
+integrando GitHub, testing, performance y seguridad. ¿El resultado? Un feature completo, modelo de base de datos, API, UI, pruebas y validaciones, pero sobre todo una
+
+00:01:02.360 --> 00:01:09.519
+nueva forma de desarrollar. La mayoría de cursos de AI te enseñan a escribir código más rápido. Este te enseña a pensar mejor antes de
+
+00:01:09.519 --> 00:01:18.779
+escribirlo. No aprendes prompts, aprendes decisiones. Y cada decisión, parte del análisis, no de la improvisación. El futuro del desarrollo no pertenece a quienes escriben
+
+00:01:18.779 --> 00:01:28.459
+más código, sino a quienes piensan mejor el código que escriben. Claude Code no acelera tu trabajo, lo eleva. [Efecto sonoro].
+

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/01-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/claude-code

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/02-Flujo profesional para desarrollar features con Claude Code.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53f291bef5143e9c1fd6b4ab8d4c5086dc6b7e725880ac0d964a7865369f2edf
+size 35495055

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/02-Flujo profesional para desarrollar features con Claude Code.vtt

@@ -0,0 +1,38 @@
+WEBVTT
+
+00:00:00.079 --> 00:00:09.359
+Cada desarrollador que llega a un proyecto nuevo repite el mismo ritual: clona repositorio, abre carpetas, revisa archivos, toma notas y aun así siente que
+
+00:00:09.359 --> 00:00:17.659
+no entiende nada. Esto no es falta de habilidad, es falta de método. Por eso, antes de empezar, necesitas saber algo muy claro: este curso
+
+00:00:17.659 --> 00:00:29.020
+es técnico. Si no tienes bases, vas a frustrarte. Necesitas entender qué es la terminal, Git, API REST, bases de datos relacionales y arquitectura cliente-servidor.
+
+00:00:29.020 --> 00:00:37.700
+Trabajaremos con FastAPI, Next. js, Docker y Playwright. No necesitas ser experto, pero sí debes saber qué es un endpoint, una migración o un componente
+
+00:00:37.700 --> 00:00:44.880
+con estado. Si todo esto te suena nuevo, empieza con los cursos base y regresa cuando tengas estos fundamentos. Te dejaré en la sección de
+
+00:00:44.880 --> 00:00:52.439
+recursos los enlaces a los cursos que necesitas tomar previamente. Si ya los manejas, este curso te va a dar herramientas profesionales que puedes aplicar
+
+00:00:52.439 --> 00:00:59.380
+desde hoy. Y si aún no has instalado Cloud Code, en la sección de recursos tienes el tutorial básico. Cada feature que construyamos seguirá un
+
+00:00:59.380 --> 00:01:12.239
+flujo simple pero poderoso: análisis, planificación y ejecución. Antes de escribir, entendemos, exploramos el codebase, identificamos modelos, dependencias y puntos de impacto. Un curso técnico
+
+00:01:12.239 --> 00:01:19.419
+con poco código. Aquí el trabajo no es escribir más, es pensar mejor. Cloud Code genera gran parte del código. Tú decides si lo que
+
+00:01:19.419 --> 00:01:29.299
+genera tiene sentido, si respeta la arquitectura y si es eficiente. Cuando analices el codebase, aprenderás referencias y análisis multiarchivo. Cuando diseñes un feature, descubrirás
+
+00:01:29.299 --> 00:01:38.479
+Think Deeply y agentes especializados. Cuando ejecutes código, conocerás comandos de validación, prueba y seguridad. Verás cómo lo que parecía complejo se vuelve claro y
+
+00:01:38.479 --> 00:01:46.319
+controlable. Cloud Code te acompañará en cada paso, como herramienta, como asistente y sobre todo, como tu nuevo colaborador técnico.
+

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/02-Lecturas recomendadas.txt

@@ -0,0 +1,4 @@
+https://www.youtube.com/watch?v=A6oW7SnNq2g
+https://platzi.com/cursos/gitgithub/
+https://platzi.com/cursos/docker-fundamentos/
+https://platzi.com/cursos/reactjs/

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/03-Instalación y configuración básica de Claude Code con npm.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f1f12f811ade326a1a559948ae1720bfb6e72afdcd093a78c727c5371721d87a
+size 104264849

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/03-Instalación y configuración básica de Claude Code con npm.vtt

@@ -0,0 +1,149 @@
+WEBVTT
+
+00:00:00.080 --> 00:00:09.459
+En esta clase vamos a aprender cómo instalar Claude dentro del sistema, cómo configurarlo muy básicamente y cómo tenerlo entonado para empezar el desarrollo. Vamos.
+
+00:00:09.460 --> 00:00:17.480
+Lo primero que haremos es ir a la documentación oficial de Claude, que es docs.claude.com. Aquí hay muchos apartados, pero el que más nos interesa
+
+00:00:17.480 --> 00:00:24.700
+es el de Claude Code, que tiene toda la documentación de cómo trabajar con Claude Code, cómo instalarlo y cuáles son los features disponibles que
+
+00:00:24.700 --> 00:00:34.780
+existen para, eh, poder sacarle el mayor provecho. Aquí, en la primera página, que es el overview, están las instrucciones de instalación. Vemos que lo
+
+00:00:34.780 --> 00:00:41.519
+que se necesita para instalar es npm, que es el manejador de paquetes de node. Si aún no lo tienes instalado en tu sistema o
+
+00:00:41.520 --> 00:00:49.500
+no está configurado, te recomiendo que visites el curso de fundamentos de JavaScript en donde aprenderás a cómo instalarlo. Lo único que se tiene que
+
+00:00:49.500 --> 00:00:59.060
+hacer es copiar esta línea... e ir a la terminal. En la terminal es pegar esta línea y esperar a que se instale el paquete.
+
+00:00:59.060 --> 00:01:08.040
+Vemos que es una instalación global, por lo que va a estar disponible para cualquier sección dentro de nuestro entorno de desarrollo, no únicamente dentro
+
+00:01:08.040 --> 00:01:16.060
+de la carpeta en la que se instaló. El segundo paso es entrar al directorio en el que se quiere trabajar. En este caso, nosotros
+
+00:01:16.060 --> 00:01:25.020
+ya estamos dentro del directorio de Claude Code, que es la carpeta en la que vamos a estar trabajando. Y luego, simplemente hay que escribir
+
+00:01:25.020 --> 00:01:32.900
+el comando Claude. Y aquí se va a abrir algo que se llama REPL, que nos va a permitir tener una interfaz con la que
+
+00:01:32.900 --> 00:01:41.780
+podemos interactuar con el modelo. Y aquí nos dice unas pequeñas instrucciones: el comando help para buscar ayuda y entender cómo funciona Claude Code, el
+
+00:01:41.780 --> 00:01:50.430
+comando status para ver qué tal está el setup actual de, de, de Claude Code. Vamos a escribir help para entender cómo es que funciona
+
+00:01:50.430 --> 00:01:59.500
+un comando y, este, particularmente, lo que nos dice una documentación o un manual muy básico de cómo es que funciona Claude Code. Y aquí
+
+00:01:59.500 --> 00:02:06.400
+nos dice que siempre revisemos las respuestas de Claude, etcétera. Nos da una lista de cuáles son los comandos en el modo interactivo que, que
+
+00:02:06.400 --> 00:02:14.100
+están disponibles. Por ejemplo, aquí está el que acabamos de usar, que es help, que nos muestra los comandos disponibles y muestra ayuda. Y hay
+
+00:02:14.100 --> 00:02:23.260
+otro que es el comando doctor, que ese es el segundo comando que quiere introducir, que es, eh, revisar cómo está la instalación de Claude
+
+00:02:23.260 --> 00:02:31.040
+Code y los settings de, de Claude Code. Entonces vamos a darle enter porque es la forma en la que se sale, y escribimos doctor.
+
+00:02:31.040 --> 00:02:37.620
+Y en doctor me está diciendo que todo está correcto, que, que, que está instalado en esta, en esta parte del sistema, que está siendo
+
+00:02:37.620 --> 00:02:45.440
+invocado en este binario y que todo está correcto. No hay mucho más, pero que esto nos va a-- puede ayudar si llega a haber
+
+00:02:45.440 --> 00:02:52.740
+algún problema con la invocación de Claude, este nos va a dar un indicio de qué puede estar fallando. Y el tercer comando que necesitamos
+
+00:02:52.740 --> 00:03:02.079
+es login. Sin el login no podremos utilizar los modelos disponibles ni utilizarlo para poder generar código. Cuando le damos login, él nos muestra dos
+
+00:03:02.080 --> 00:03:10.920
+opciones: uno que es utilizar a Claude con la suscripción a Anthropic y otro que es utilizar a Claude con la consola de Anthropic. Tiene
+
+00:03:10.920 --> 00:03:19.980
+sus diferencias. Uno es: si se paga la suscripción, se tiene acceso a la aplicación de escritorio de Claude y también acceso a Claude Code.
+
+00:03:19.980 --> 00:03:26.800
+Si se paga, por ejemplo, el plan pro, que es el más barato, se tiene acceso solo a algunos modelos, en este caso Sonnet, pero
+
+00:03:26.800 --> 00:03:35.020
+no al más avanzado, que es Opus, y a una cantidad limitada de tokens. Versus max, que sí amplía el rango a poder utilizar Opus
+
+00:03:35.020 --> 00:03:43.480
+y una mayor cantidad de tokens. Pero esto es personal. Y la de abajo es como si tú compraras tokens en la consola de Anthropic.
+
+00:03:43.480 --> 00:03:52.380
+Entonces, ya es cómo, eh, está configurado para tu entorno de trabajo, eh, el uso de Claude. Pero lo ideal es que si estás trabajando
+
+00:03:52.380 --> 00:03:58.760
+en solitario o eres un solo dev, lo puedes utilizar con la suscripción y si estás trabajando para una empresa, que puedas utilizar los tokens
+
+00:03:58.760 --> 00:04:07.320
+de la empresa. En el navegador se nos abrirá una pestaña como esta, en el que nos pregunta si queremos autorizar a Claude Code para
+
+00:04:07.320 --> 00:04:15.160
+que utilice y cree API keys dentro de la organización de Platzi, en este caso. Yo voy a autorizar esto para que se cree el
+
+00:04:15.160 --> 00:04:26.200
+token. Adicionalmente, Claude Code, cuando iniciamos sesión, nos muestra este link. Este link es si, por ejemplo, no se abre un navegador, eh, lo podemos
+
+00:04:26.200 --> 00:04:33.740
+agarrar y copiar e irnos a un navegador en el que tenemos la sesión iniciada de Anthropic. Esta es una segunda forma de poder iniciar
+
+00:04:33.740 --> 00:04:42.960
+sesión. Aquí también tenemos que autorizar o declinar. Yo voy a darle a autorizar a esta sección para que vean que aquí aparece un token.
+
+00:04:42.960 --> 00:04:55.020
+Este token se puede copiar y luego se pega en la misma terminal para que se pueda utilizar. Aquí, eh, inicia sesión, me dice que
+
+00:04:55.020 --> 00:05:04.500
+listo, que ya estoy logueado con mi cuenta de Platzi y que el login fue exitoso. Excelente. Entonces, ya tenemos a Claude Code instalado en
+
+00:05:04.500 --> 00:05:14.000
+el sistema y ya tenemos, eh, la sesión iniciada para poder utilizar los modelos. Ahora, solo hemos visto cómo utilizarlo dentro de la terminal, pero
+
+00:05:14.000 --> 00:05:23.020
+es más poderoso cuando lo unimos con el uso de un editor. En este caso, vamos a utilizar a cursor como editor para poder, eh,
+
+00:05:23.020 --> 00:05:31.500
+integrar a Claude Code dentro de él y tenerlo como herramienta de desarrollo en el mismo editor. Vamos al editor y lo que vamos a
+
+00:05:31.500 --> 00:05:41.560
+hacer es buscar dentro de la sección de, eh, extensiones, la que se llama Claude Code. Se podría utilizar a Claude Code, eh, fácilmente dentro
+
+00:05:41.560 --> 00:05:52.320
+de la misma terminal del editor, pero el plugin ofrece unas mejores opciones de poder, eh, pasarle mayor contexto y tener una mejor experiencia. Una
+
+00:05:52.320 --> 00:06:01.380
+vez se instala, va a aparecer el logo de Claude aquí en el mismo editor. Si le damos acá, se abre una nueva pestaña. Eh,
+
+00:06:01.380 --> 00:06:10.159
+le podemos decir, eh, doctor, para ver qué tal está funcionando, dice que está correcto. Le podemos dar status para certificar qué tal está funcionando.
+
+00:06:10.160 --> 00:06:17.180
+Y aquí me dice que ya la sesión está iniciada con mi correo, como lo hicimos hace un rato, que tenemos, eh, la sesión con
+
+00:06:17.180 --> 00:06:25.040
+este ID. Es decir, Claude Code ya está corriendo dentro del editor. Esta fue una instalación muy básica y rápida de Claude Code, pero que
+
+00:06:25.040 --> 00:06:33.660
+ya es utilizable en el contexto de desarrollo. Si quieres una instalación más avanzada o conocer aún más features, te recomiendo ir al curso de
+
+00:06:33.660 --> 00:06:40.980
+tips y trucos de AI, en donde hay una clase exclusiva de Claude Code. En la próxima clase, vamos a definir cuál es la metodología
+
+00:06:40.980 --> 00:06:47.880
+de trabajo para el resto del curso, cómo es que Claude Code nos va a apoyar con sus herramientas para determinar qué tareas hacer y
+
+00:06:47.880 --> 00:06:49.560
+cómo hacerlas. Nos vemos allá.
+

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/03-Lecturas recomendadas.txt

@@ -0,0 +1,2 @@
+https://platzi.com/cursos/trucos-ia/
+https://platzi.com/cursos/javascript/

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/04-Fundamentos de Claude Code contexto subagentes y herramientas.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:51b7bc14c678c3d71e91f772647443162641712da64b89b9ce57346aada89a1b
+size 86272979

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/04-Fundamentos de Claude Code contexto subagentes y herramientas.vtt

@@ -0,0 +1,95 @@
+WEBVTT
+
+00:00:00.180 --> 00:00:07.160
+Antes de empezar a usar a Claude Code dentro del proyecto, necesitas comprender los fundamentos que lo hacen distinto a cualquier otra herramienta de inteligencia
+
+00:00:07.160 --> 00:00:18.759
+artificial. Cinco conceptos determinan cómo piensa, cómo recuerda y cómo colabora contigo. La ventana de contexto, los subagentes, el Model Context Protocol, la CLI y
+
+00:00:18.760 --> 00:00:27.419
+el context engineering. No necesitas ser experto en ninguno, pero entenderlos te permitirá usar Claude Code con intención, precisión y confianza. La ventana de contexto
+
+00:00:27.420 --> 00:00:35.360
+es toda la información que Claude puede procesar y recordar al mismo tiempo: tu código, la conversación y los resultados que genera. Es, literalmente, su
+
+00:00:35.360 --> 00:00:43.310
+memoria de trabajo. Claude Code maneja doscientos mil tokens en la versión por defecto y tiene una versión de un millón de tokens, suficiente para
+
+00:00:43.310 --> 00:00:52.240
+analizar proyectos medianos o incluso grandes. Cuando esa memoria se llena, Claude empieza a olvidar información antigua. Pero no te preocupes, Claude Code gestiona ese
+
+00:00:52.240 --> 00:01:00.680
+espacio automáticamente. Limpia datos irrelevantes y conserva solo lo que sigue siendo útil. En la práctica, esto significa que puedes referenciar archivos con el símbolo
+
+00:01:00.680 --> 00:01:08.310
+arroba en lugar de copiar grandes bloques de código. Si notas que Claude olvida alguna decisión o contexto, simplemente abre una nueva sesión y vuelve
+
+00:01:08.310 --> 00:01:16.899
+a referenciar los archivos clave. Así optimizas la memoria y mantienes la conversación enfocada. Los subagentes funcionan como miembros especializados de tu equipo. Son versiones
+
+00:01:16.900 --> 00:01:27.320
+de Claude enfocadas en tareas específicas: backend, frontend, QA, arquitectura, etcétera. Cada uno tiene su propio contexto, herramientas y conocimiento técnico. Por ejemplo, el arquitecto
+
+00:01:27.320 --> 00:01:35.780
+analiza la estructura general del sistema, el backend implementa las APIs, el frontend construye los componentes de interfaz y QA se encarga de validar la
+
+00:01:35.780 --> 00:01:43.899
+calidad final. Puedes invocar a cada uno según la tarea que necesites resolver. Agente de backend para endpoints o agente de frontend para componentes. Mientras
+
+00:01:43.900 --> 00:01:53.660
+trabajan, mantienen sus contextos separados y no saturan la sesión principal. El resultado es un flujo modular, donde cada agente se enfoca en su especialidad,
+
+00:01:53.660 --> 00:02:00.360
+igual que en un equipo de desarrollo real. El tercer concepto es el Model Context Protocol o MCP. Este es el sistema que permite que
+
+00:02:00.360 --> 00:02:07.100
+Claude Code se conecte con herramientas externas. Gracias a MCP, Claude no se limita a leer archivos de código. Puede acceder a bases de datos,
+
+00:02:07.100 --> 00:02:15.160
+ejecutar pruebas automatizadas, revisar issues en GitHub o incluso interactuar con servicios como Figma o Zapier. Esto significa que puedes pedirle a Claude que corra
+
+00:02:15.160 --> 00:02:22.020
+pruebas en Playwright directamente desde la conversación, que revise un pull request o que consulte datos de una API sin salir de la terminal. Todo
+
+00:02:22.020 --> 00:02:30.299
+eso ocurre de forma natural, porque MCP integra esas herramientas como si fueran funciones nativas. Solo necesitas configurar cada conexión una vez y a partir
+
+00:02:30.300 --> 00:02:37.980
+de ahí, cualquier miembro del equipo puede usarlas conversacionalmente. Claude Code se convierte así en el puente que conecta tu proyecto con todo tu ecosistema
+
+00:02:37.980 --> 00:02:45.840
+de herramientas. El cuarto concepto es la CLI, la interfaz donde todo ocurre. Claude Code no tiene una interfaz gráfica, vive en la terminal, el
+
+00:02:45.840 --> 00:02:53.720
+mismo lugar donde ya usas Git, Docker o NPM. Esa es precisamente su ventaja. Usa comandos del sistema con el prefijo signo de exclamación. Claude
+
+00:02:53.720 --> 00:03:01.720
+no te dice qué deberías ejecutar, lo ejecuta, analiza los resultados y te ayuda a interpretarlos. Esto mantiene tu flujo limpio: la terminal para Claude,
+
+00:03:01.720 --> 00:03:10.700
+el editor para escribir código y el navegador para validar resultados. Claude no necesita prompts perfectos, necesita que le construyas un contexto útil, un entorno
+
+00:03:10.700 --> 00:03:18.430
+de información donde puedas razonar con precisión. No se trata de escribir una gran instrucción, sino de darle los datos adecuados. Eso es el context
+
+00:03:18.430 --> 00:03:28.660
+engineering. Una instrucción vaga genera ruido. Por ejemplo: «Ayúdame con el código». No tiene suficiente información. En cambio, una instrucción con contexto produce resultados precisos.
+
+00:03:28.660 --> 00:03:37.580
+El context engineering es usar referencias a archivos en lugar de copiar código, explicar el propósito de la tarea, indicar qué patrones seguir o evitar
+
+00:03:37.580 --> 00:03:47.360
+y mantener la conversación limpia de información innecesaria. No estás haciendo prompting, estás diseñando un espacio de pensamiento compartido con la inteligencia artificial. Ese espacio,
+
+00:03:47.360 --> 00:03:57.360
+el contexto, es lo que define la calidad del resultado. Estos cinco conceptos resumen la ventaja de Claude Code: el contexto, la especialización por subagentes,
+
+00:03:57.360 --> 00:04:06.660
+el MCP, la CLI y el context engineering. Claude Code no necesita que aprendas a escribir prompts, necesita que aprendas a crear el contexto donde
+
+00:04:06.660 --> 00:04:14.680
+las decisiones tienen sentido. Durante el curso, verás estos conceptos en acción. El poder de Claude Code no está en escribir más líneas de código,
+
+00:04:14.680 --> 00:04:17.660
+sino en pensar dentro del contexto correcto.
+

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/05-Análisis de arquitectura full stack con Claude Code.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:73b177b71b854d903bcdb8095dd717fa13b4a9a2d960ab84435bc6eca523d34d
+size 186111505

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/05-Análisis de arquitectura full stack con Claude Code.vtt

@@ -0,0 +1,257 @@
+WEBVTT
+
+00:00:00.120 --> 00:00:08.840
+En esta clase utilizaremos a Cloud Code para entender la arquitectura de una base de código ya existente. Y también vamos a utilizarlo para configurar
+
+00:00:08.840 --> 00:00:18.940
+el entorno de desarrollo. Vamos al editor. En el editor abriremos el proyecto y veremos que tiene tres carpetas: backend, frontend y móvil. Eso significa
+
+00:00:18.940 --> 00:00:26.640
+que este proyecto es un proyecto full stack, pero de primera mano no conocemos cómo es la arquitectura. Con Cloud Code vamos a utilizar varias
+
+00:00:26.640 --> 00:00:38.190
+herramientas para poder entenderla. Entonces, abrimos Cloud Code dentro del propio editor y escribimos un prompt sencillo, pero que su fin sea indicarle a Cloud
+
+00:00:38.190 --> 00:00:50.280
+que debe analizar el proyecto y que nos dé un resumen de cómo es su arquitectura. «Analiza el proyecto y entiende cómo es la arquitectura
+
+00:00:50.340 --> 00:01:04.200
+que tiene. Es importante que entiendas que hay más de un proyecto contenido en él». Y aquí nos vamos a apoyar del feature de Cloud
+
+00:01:04.200 --> 00:01:12.040
+Code, que es mencionar a los archivos. Con el arroba se nos va a dar aquí un pequeño explorador de archivos en el que podemos
+
+00:01:12.040 --> 00:01:21.700
+mencionar no únicamente folders, sino también archivos. Entonces, aquí me interesa, es decirle que tiene o que debe tener el contexto de que existe backend,
+
+00:01:21.700 --> 00:01:44.360
+frontend y móvil. «Utiliza a estas carpetas para crear un big picture completo de la arquitectura del sistema». Excelente. Con esto ya tenemos un prompt
+
+00:01:44.360 --> 00:01:55.460
+básico que nos va a permitir, eh, tener como resultado un análisis de la arquitectura. Le estamos dando contexto sobre qué partes necesitamos que tenga
+
+00:01:55.460 --> 00:02:04.320
+para hacer el análisis de arquitectura, haciéndole esta, estos mentions a los folders. Con esto le hacemos enter y ahí, eh, Cloud Code va a
+
+00:02:04.320 --> 00:02:13.209
+empezar a hacer su trabajo. Aquí lo primero que nos dice es que va a analizar la estructura del proyecto y va a entender la
+
+00:02:13.209 --> 00:02:24.700
+arquitectura completa. Que lo primero que va a hacer es explorar el directorio principal y luego examinar cada componente. Esto puede tardar varios minutos porque
+
+00:02:24.700 --> 00:02:34.580
+necesita tomar el contexto completo del proyecto, enviarlo al LLM y el LLM luego entiende cómo es la base de código. Muchas veces nos vamos
+
+00:02:34.580 --> 00:02:43.640
+a encontrar con que Cloud Code necesita permisos explícitos para poder ejecutar una acción. En este caso, va a ejecutar un comando dentro de la
+
+00:02:43.640 --> 00:02:56.959
+terminal que va a ser: encontrar en la carpeta frontend src cualquier archivo que contenga este formato: punto TSX, punto TS, punto JS o punto
+
+00:02:56.960 --> 00:03:05.700
+GSX. Y va a obtener las primeras quince líneas de esos archivos. Como es un comando de búsqueda y es seguro utilizarlo, yo le voy
+
+00:03:05.700 --> 00:03:14.120
+a decir que sí. Aquí vemos el resultado que dio Cloud Code del análisis completo que hizo del proyecto. Vemos que primero lo que nos
+
+00:03:14.120 --> 00:03:24.700
+está diciendo es un resumen muy rápido de qué es este proyecto. Y dice que es un sistema educativo online que siga arquitectura multiplataforma con
+
+00:03:24.700 --> 00:03:35.940
+tres componentes principales: backend, frontend y móvil. Y móvil tiene las dos plataformas: Android y iOS. También detectó cuál es el stack de cada uno,
+
+00:03:35.940 --> 00:03:43.960
+en este caso el backend de Python para hacer el API y el frontend con Next.js. Aquí me está haciendo un resumen muy básico de
+
+00:03:43.960 --> 00:03:51.140
+cómo es, eh, la, la estructura de carpetas que tiene el, el proyecto en el backend, cuál es el framework que está utilizando, que en
+
+00:03:51.140 --> 00:03:59.680
+este caso FastAPI, con la base de datos de Postgres, etcétera. Reconoció muy bien cuáles son las características de este stack. Me hace una lista
+
+00:03:59.680 --> 00:04:07.600
+también de cuáles son los modelos y cuáles son los endpoints que están disponibles. Para el frontend, algo muy similar. Me dice cuáles son las
+
+00:04:07.600 --> 00:04:18.600
+características que, por ejemplo, tiene Server Side Rendering y Server Side Generation con Next.js. Tiene responsive design utilizando grid al estilo Netflix, tiene una integración
+
+00:04:18.600 --> 00:04:27.220
+con la API a través de Fetch nativo y tiene una navegación dinámica. Y un análisis muy similar para móvil. Esto me parece muy importante
+
+00:04:27.220 --> 00:04:36.860
+porque también está identificando cómo es que se utiliza o cómo es el ciclo de vida del request que sucede. Por ejemplo, la mobile app
+
+00:04:36.860 --> 00:04:44.340
+hace una petición al backend, el frontend también hace una petición al backend, el backend a la base de datos, etcétera. Es decir, está siendo
+
+00:04:44.340 --> 00:04:50.860
+un end-to-end de cómo es que ocurre una petición en cualquiera de los clientes, cómo va el backend y luego cómo va la base de
+
+00:04:50.860 --> 00:04:59.180
+datos. Eso está muy impresionante, está muy completo y a mí me interesa que esto quede dentro del proyecto. Que es lo que yo le
+
+00:04:59.180 --> 00:05:08.920
+voy a pedir ahora, que este resumen y este análisis de arquitectura que acaba de hacer lo guarde dentro del archivo cloud.md, que es el
+
+00:05:08.920 --> 00:05:17.320
+sistema de memoria que tiene Cloud para, eh, poder trabajarlo dentro de un proyecto. Y eso es muy fácil, se le puede dar una indicación
+
+00:05:17.320 --> 00:05:35.580
+a Cloud para que lo pueda guardar. Le decimos primero: «Gracias. Excelente análisis de arquitectura. Ahora, con esta información que tienes en el contexto, crea
+
+00:05:35.580 --> 00:05:54.860
+el archivo cloud.md para que se pueda utilizar como memoria para el resto de el desarrollo de este proyecto». Muy bien, le damos enter y
+
+00:05:54.860 --> 00:06:04.512
+aquí él va a utilizar el contexto que ya tiene dentro de su propia memoria y guardarlo en el archivo cloud.md. Vemos que Cloud Code...Eh,
+
+00:06:04.512 --> 00:06:13.752
+como está integrado dentro del propio editor, me está pidiendo que acepte la recomendación. Esto es un comportamiento que está integrado dentro de los editores.
+
+00:06:13.752 --> 00:06:22.131
+Si lo estuviéramos utilizando únicamente en la terminal, solo tendríamos esta caja de texto en el que tenemos que indicar si aceptamos lo que nos
+
+00:06:22.132 --> 00:06:31.111
+dijo, si aceptamos y permitimos cualquier edición durante esta sesión de Cloud Code o si lo rechazamos por completo y le damos feedback. Vamos a
+
+00:06:31.111 --> 00:06:41.232
+leerlo antes de aceptarlo para garantizar que lo que escribió tenga sentido. Describe cuál es la arquitectura, muestra cuáles son los componentes que tiene backend,
+
+00:06:41.232 --> 00:06:51.852
+frontend y móvil. Eh, describe cuál es el stack. Muestra cuál es la estructura del proyecto, cuáles son las relaciones... O sea, es prácticamente lo
+
+00:06:51.852 --> 00:07:00.472
+mismo que nos dio en la conversación, pero guardado en el archivo cloud.md. En este caso, yo le voy a dar a aceptar. Podría hacerlo
+
+00:07:00.472 --> 00:07:09.152
+desde acá o podría hacerlo desde acá. Yo aquí le puedo decir que sí, que lo acepto. Y entonces el archivo ya existe como archivo
+
+00:07:09.152 --> 00:07:19.251
+dentro de el proyecto y se llama cloud.md. Muy bien. Ya. Él me avisa que terminó y que ha creado el archivo en la raíz
+
+00:07:19.251 --> 00:07:28.532
+del proyecto y que incluye todo lo que analizamos antes de, de aceptarlo. Ahora, además de hacer el análisis de arquitectura y hacer ese top
+
+00:07:28.532 --> 00:07:38.751
+de la memoria, me interesa, por lo menos, tener corriendo el backend de este servicio en mi entorno local de desarrollo. Entonces, vamos a pedirle
+
+00:07:38.751 --> 00:07:55.611
+que me ayude a instalar ese servicio aquí en mi computadora. Ahora, ayúdame a tener el sistema, mejor, el servicio de backend corriendo en mi
+
+00:07:55.611 --> 00:08:07.932
+local. Verás que ya tengo docker instalado y listo para correr. Le dije lo de docker especialmente, ¿por qué? Porque Cloud Code puede ejecutar comandos
+
+00:08:07.932 --> 00:08:14.912
+de CLI, como vimos hace un rato, en el que le dimos permiso. Él lo que debería hacer es ver primero si docker está, eh,
+
+00:08:14.912 --> 00:08:25.202
+funcionando. ¿Por qué? Porque antes se dio cuenta de que este proyecto tenía un contenedor y está anotado dentro del cloud.md. Efectivamente, lo que me
+
+00:08:25.202 --> 00:08:32.812
+está pidiendo hacer, eh, de primeras es ver cuál es la versión de docker que tengo instalado. Yo aquí se lo voy a permitir y
+
+00:08:32.812 --> 00:08:43.972
+de nuevo nos muestra opciones. ¿Qué puedo hacer? Permitir una vez que se ejecute, eh, docker. Permitir y consecutivamente permitir que se ejecuten comandos de
+
+00:08:43.972 --> 00:08:52.872
+docker para este proyecto o decirle que no. Yo en este caso le voy a decir la opción dos, que es que sí permita ejecutar
+
+00:08:52.872 --> 00:09:01.912
+comandos de docker para este proyecto. Aquí ve que tengo la versión de docker, eh, dos punto treinta y ocho dentro del sistema y también
+
+00:09:01.912 --> 00:09:10.531
+en la versión de docker compose. Eh, aquí está viendo cómo es que, eh, se, se, se utiliza el backend. Primero entró a la carpeta
+
+00:09:10.531 --> 00:09:17.531
+y luego le hizo, eh, para saber cuál es la dirección, la ruta absoluta de esto. Ahí entró y se dio cuenta que hay un
+
+00:09:17.531 --> 00:09:27.232
+archivo make que tiene un comando start. Le vamos a decir que sí. Okey. Esto es interesante. ¿Por qué? Porque el make start está dando
+
+00:09:27.232 --> 00:09:37.372
+un error al levantar el sistema. Esto sirve como contexto. Cada vez que se ejecuta un comando en Cloud Code, se agrega a la conversación
+
+00:09:37.372 --> 00:09:45.332
+y Cloud tiene de inmediato el feedback de qué está fallando. Entonces, aquí dice que indica que el daemon de docker no está corriendo. Hay
+
+00:09:45.332 --> 00:09:54.812
+que iniciarlo primero. Entonces, vamos a darle que sí, que haga esto. Eso va a prender docker dentro del sistema, en mi computadora, particularmente. Y
+
+00:09:54.812 --> 00:10:02.052
+aquí es interesante, él hace un slip, es decir, va a esperar diez segundos y luego ejecuta un comando básico de docker que es docker
+
+00:10:02.052 --> 00:10:09.312
+ps, que lo que permite es ver cuáles son los, los contenedores que están corriendo. Y aquí dice que listo, que docker ya está corriendo.
+
+00:10:09.312 --> 00:10:17.952
+Entonces, efectivamente estamos viendo que él ve que hay un error, toma el feedback y empieza a tomar acciones para corregir ese error. En este
+
+00:10:17.952 --> 00:10:29.191
+caso, fue levantar docker. Aquí ya está haciendo para poder instalar o poner a funcionar los contenedores de este sistema. Me dice que ya están,
+
+00:10:29.192 --> 00:10:39.332
+eh, corriendo. Aquí se está certificando de que está corriendo. Quiere ver los logs. Aquí tiene acceso ya a los logs de este contenedor. En
+
+00:10:39.332 --> 00:10:47.872
+este caso, vemos que ejecutó el make logs y Cloud Code se queda esperando a que este comando termine. Pero si vamos a la definición
+
+00:10:47.872 --> 00:10:56.432
+de qué hace el make logs, vemos que siempre se queda esperando por los logs de este contenedor. Es decir, nunca va a terminar de
+
+00:10:56.432 --> 00:11:06.932
+ejecutar. Pero Cloud Code tiene la funcionalidad de poder poner en background esta ejecución. Aquí dice que con el control B lo podemos mandar al
+
+00:11:06.932 --> 00:11:15.311
+background. Entonces, vamos a mandarlo al background. Y aquí va a continuar con su ejecución y nos muestra que abajo tenemos algo corriendo que es
+
+00:11:15.311 --> 00:11:22.912
+el main logs. Aquí se dio cuenta de que hay un problema y que debe matar al proceso que estaba ejecutando el main logs para
+
+00:11:22.912 --> 00:11:33.132
+luego ponerlo a funcionar. Aquí vemos que dice que está corriendo la base de datos, que está corriendo la API y que necesita ejecutar migraciones.
+
+00:11:33.132 --> 00:11:42.112
+Vamos a decirle que sí. Listo, las migraciones se ejecutaron correctamente y va a poblar la base de datos con los datos de prueba. Todo
+
+00:11:42.112 --> 00:11:50.492
+esto es, eh, fácil de usar porque el proyecto ya tiene un buen archivo make en el que están explícitas los comandos que se pueden
+
+00:11:50.492 --> 00:11:58.932
+utilizar. Entonces, en este caso el seed no funcionó porque me dice que ya existe, eh, este email en la base de datos. Esto solo
+
+00:11:58.932 --> 00:12:07.412
+pasa porque yo ya tenía el proyecto instalado dentro de mi sistema antes de empezar la clase. Pero eso seguramente no va a pasar cuando,
+
+00:12:07.412 --> 00:12:13.712
+eh, lo intentes hacer por ti mismo. Igual hay un comando que se llama seed fresh, que lo que hace es refrescar esos seeds en
+
+00:12:13.712 --> 00:12:22.602
+la base de datos. Borra todos los datos y los vuelve a crear. Y aquí está haciendo comandos curl, es decir, está haciendo peticiones ya
+
+00:12:22.602 --> 00:12:31.152
+al servicio de API para garantizar que esté corriendo. Vamos a darle que sí. Y efectivamente, todos los endpoints a los que le hizo el,
+
+00:12:31.152 --> 00:12:40.752
+el request están respondiendo con los datos que está esperando. Es decir, Cloud Code se dio cuenta de cómo es que debe, eh, utilizar los
+
+00:12:40.752 --> 00:12:50.232
+comandos make para poner a funcionar este proyecto en el entorno local. Yo únicamente revisé y certifiqué que los comandos que intentaba ejecutar no eran
+
+00:12:50.232 --> 00:12:59.692
+comandos peligrosos. Por ejemplo, podría, de pura alucinación, hacer un comando que sea eliminar todos los archivos en el computador. Yo eso no lo voy
+
+00:12:59.692 --> 00:13:06.070
+a aceptar. Pero todo lo que me dio y todos los comandos que me, que me entregó acá y que acepté eran comandos que tenían
+
+00:13:06.072 --> 00:13:15.372
+sentido. Y de esta forma ya tenemos el backend corriendo exitosamente en el sistema. Cloud Code es una herramienta muy poderosa, con muy pocos prompts
+
+00:13:15.372 --> 00:13:25.531
+y muy sencillos en español, ya tenemos dentro del sistema la documentación necesaria para que Cloud tenga memoria de la arquitectura del servicio. Ya sabemos
+
+00:13:25.531 --> 00:13:34.531
+nosotros cuál es la arquitectura del proyecto que nos acaban de asignar y ya tenemos el backend corriendo en el sistema. En la próxima clase,
+
+00:13:34.531 --> 00:13:40.252
+vamos a empezar a utilizar a Cloud Code en el desarrollo de un feature nuevo dentro de esta misma base de código.
+

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/05-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/claude-code

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/06-Análisis de impacto del feature de ratings con Claude Code.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f690e07389782085f491ae140f1da9e9f6625f9945fed69fb8bc4255d8a3f4a
+size 83882065

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/06-Análisis de impacto del feature de ratings con Claude Code.vtt

@@ -0,0 +1,119 @@
+WEBVTT
+
+00:00:00.260 --> 00:00:07.720
+Ahora haremos el análisis técnico del feature de ratings, que fue esta tarea que se nos asignó cuando empezamos a trabajar en este proyecto. Nos
+
+00:00:07.720 --> 00:00:15.360
+apoyaremos en Cloud Code y los tres niveles de pensamiento extendido para poder tomar el contexto necesario de qué cambios hay que hacer dentro del
+
+00:00:15.360 --> 00:00:25.900
+proyecto para la implementación de este feature. Vamos al editor. Abrimos Cloud Code y lo que ya tenemos disponible es la memoria que creamos en
+
+00:00:25.900 --> 00:00:34.020
+la clase anterior, que muestra cómo es la arquitectura del sistema y cuáles son sus componentes. Entonces, ya podemos pedirle que haga cosas más avanzadas
+
+00:00:34.020 --> 00:00:42.240
+porque ya tenemos un contexto suficiente. El primer feature con el que nos vamos a apoyar para pensar en cómo hacer la implementación de los
+
+00:00:42.240 --> 00:00:53.540
+ratings es el Think, que significa «pensar». Recordemos que Cloud Code utiliza un modelo que tiene pensamiento extendido o razonamiento, y para activarlo tenemos tres
+
+00:00:53.540 --> 00:01:05.280
+palabras claves: think, que piensa de una forma no tan profunda, sino más bien superficial, pero útil en ciertos casos. Think deeply, que es pensar
+
+00:01:05.280 --> 00:01:15.500
+más profundamente sobre el problema. Y por último, ultrathink. Vemos que para cada uno de ellos el color de la palabra cambia, especialmente en ultrathink,
+
+00:01:15.500 --> 00:01:28.240
+donde pone este arco iris. Para este caso, vamos a habilitar el think deeply, porque no necesitamos que piense tan profundamente o ultrathinking, ni tampoco
+
+00:01:28.240 --> 00:01:44.700
+tan básicamente como think. Y aquí le dimo-- le damos la instrucción inicial, que es: «Necesito implementar un sistema de ratings en este proyecto». Y
+
+00:01:44.700 --> 00:01:59.740
+le damos un poco más de contexto. «El rating de un curso puede ir desde una estrella hasta cinco estrellas». Y aquí le vamos a
+
+00:01:59.740 --> 00:02:15.160
+indicar qué es lo que necesitamos que haga. «Tu tarea es analizar el impacto que va a tener la implementación de este feature en el
+
+00:02:15.160 --> 00:02:36.200
+proyecto. Analiza qué acciones deben hacerse en cada uno de los componentes de el proyecto». Aquí entre paréntesis vamos a poner backend, frontend y vamos
+
+00:02:36.200 --> 00:02:48.700
+a excluir a móvil solo para efectos de prueba, y te lo dejo como tarea. «Para implementar el rating». ¿En este caso, qué espero? Espero
+
+00:02:48.700 --> 00:02:57.920
+que piense profundamente qué es lo que debe hacer tanto en backend como en frontend para implementar el sistema de rating de, eh, uno a
+
+00:02:57.920 --> 00:03:09.080
+cinco estrellas. Entonces, le damos enter y lo que vamos a ver es un comportamiento distinto al que teníamos anteriormente, que es ver el razonamiento
+
+00:03:09.080 --> 00:03:15.740
+que está teniendo el modelo sobre la tarea que le estamos pidiendo. Esto que estamos viendo que está en letra cursiva es lo que él
+
+00:03:15.740 --> 00:03:24.680
+está pensando. Y aquí dice que «el usuario me está, me pide analizar el impacto de implementar un sistema ratings en el proyecto Platiflix». Y
+
+00:03:24.680 --> 00:03:31.560
+este es el razonamiento interno del modelo, no es la salida final, sino lo que está pensando. Y aquí dice que va a analizar el
+
+00:03:31.560 --> 00:03:39.980
+impacto de implementar un sistema ratings. Esto sí es su salida. Luego sigue pensando y vemos que sigue, eh, haciendo como-- haciéndose preguntas de qué
+
+00:03:39.980 --> 00:03:46.660
+es lo que tiene que hacer para poder cumplir con la tarea que yo le estoy pidiendo. En este caso, ya nos dio el resumen
+
+00:03:46.660 --> 00:03:54.220
+final de cuál es el análisis de impacto para implementar el sistema ratings. Aquí me da una tabla en el que considera cada uno de
+
+00:03:54.220 --> 00:04:03.020
+los componentes, cuáles son los archivos que debe, eh, utilizar o afectar, en este caso utiliza ese verbo, cuál es la complejidad y cuál es
+
+00:04:03.020 --> 00:04:12.200
+el tiempo estimado para cada una de las tareas. Dice cuáles son las consideraciones críticas que, que, que analizó o que se dio cuenta, cuál
+
+00:04:12.200 --> 00:04:22.019
+es la implementación recomendada y cuál es el impacto estimado. Pero en este caso, y aunque nosotros lo dijimos explícitamente en el prompt, lo integró,
+
+00:04:22.019 --> 00:04:30.280
+eh, tanto las plataformas móviles de iOS y Android en el análisis de impacto. Tenemos que decirle que lo excluyan el, en el informe final,
+
+00:04:30.280 --> 00:04:38.900
+porque esto no es algo que, que es mi misión en este momento, sino simplemente hacer la implementación tanto en backend como en frontend. Eso
+
+00:04:38.900 --> 00:04:52.720
+es un simple prompt en el que se le necesita decir, eh, no es requerido el análisis de impacto para las plataformas móviles, solo con
+
+00:04:52.720 --> 00:05:01.159
+frontend y backend basta. En este caso no le voy a activar los modos de pensamiento porque no es necesario, no es algo en lo
+
+00:05:01.160 --> 00:05:08.100
+que yo necesite que él piense de más ni, ni analice extra, sino que es una instrucción básica que me sirve con lo que ya
+
+00:05:08.100 --> 00:05:17.000
+le estoy indicando. Ya hizo la modificación necesaria para, en este caso, no tomar en cuenta las plataformas móviles, sino simplemente backend y frontend. Muy
+
+00:05:17.000 --> 00:05:25.840
+bien, esto nos sirve como contexto. Este es el inicio del contexto que nosotros necesitamos para poder crear un plan de implementación, analizar qué es
+
+00:05:25.840 --> 00:05:33.380
+lo que se debe modificar, en qué parte se debe hacer las modificaciones y cómo es un análisis inicial de qué es lo que debemos
+
+00:05:33.380 --> 00:05:45.300
+hacer. Pero esto no es suficiente. De esta forma ya tenemos el impacto total de integrar el rating al sistema de Platiflix. Ya vemos que
+
+00:05:45.300 --> 00:05:52.979
+excluyó a las plataformas móviles tal cual le dijimos en el prompt anterior. Tenemos un análisis inicial y básico de qué es lo que se
+
+00:05:52.980 --> 00:06:00.240
+debe hacer tanto en la base de datos, en el modelo del backend, en los endpoints y también qué es lo que se debe hacer
+
+00:06:00.240 --> 00:06:10.380
+en el frontend para poder integrarlo. Aprendimos los tres modos de pensamiento de Cloud Code: Think, Think Deeply y Ultrathink. Los utilizamos para poder tomar
+
+00:06:10.380 --> 00:06:20.080
+contexto y hacer un análisis inicial de qué podemos hacer para integrar el sistema de ratings al servicio de Platiflix. En la próxima clase, utilizaremos
+
+00:06:20.080 --> 00:06:26.500
+este contexto ya construido para crear un plan de implementación sólido que utilizaremos el resto del curso.
+

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/07-Creación de subagentes especializados en Claude Code para planificación.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:860345ce510f39d2241c401d4bb74d15e47243119d473a928c1932cf38446913
+size 160129821

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/07-Creación de subagentes especializados en Claude Code para planificación.vtt

@@ -0,0 +1,218 @@
+WEBVTT
+
+00:00:00.120 --> 00:00:08.820
+Cloud Code es un agente de codificación. Esto significa que tiene herramientas y se apoya en modelos grandes de lenguaje para cumplir su tarea. Pero
+
+00:00:08.820 --> 00:00:18.320
+uno de sus features principales es poder crear subagentes especializados en realizar una tarea puntual. En esta clase, vamos a crear un subagente que nos
+
+00:00:18.320 --> 00:00:26.900
+va a permitir crear un plan de implementación del feature de ratings utilizando el contexto que creamos de la clase anterior. Vamos al editor. En
+
+00:00:26.900 --> 00:00:35.820
+el editor, abrimos a Cloud Code y lo primero que vamos a hacer es aprender a cómo retomar el contexto de la conversación anterior. Cómo
+
+00:00:35.820 --> 00:00:42.840
+cerré y volví a abrir Cloud, es como si estuviera en una nueva conversación. Pero hay un comando que se llama resume. Y en resume
+
+00:00:42.840 --> 00:00:51.840
+se me hace una lista de cuáles fueron las conversaciones que yo he tenido, hace cuánto tiempo y sobre qué rama. En este caso, voy
+
+00:00:51.840 --> 00:01:00.180
+a utilizar la segunda, que fue hace, eh, diez minutos, en la que tenemos el contexto que extrajimos y que creamos en la clase anterior,
+
+00:01:00.180 --> 00:01:10.720
+que fue utilizando el ultrathink, el di-- el think deeply y el think para tomar el contexto de las modificaciones del feature de rating. Ahora,
+
+00:01:10.720 --> 00:01:19.400
+para crear el subagente, Cloud Code también tiene un comando que se llama agents. Y este tiene una particularidad de-- que es crear un nuevo
+
+00:01:19.400 --> 00:01:29.140
+agente. Voy a seleccionarlo. Voy a elegir en qué contexto quiero que se ejecute. Puede ser para personal, es decir, que esté dentro de todos
+
+00:01:29.140 --> 00:01:38.280
+los proyectos en mi computadora o únicamente para este proyecto. Yo lo quiero hacer para el proyecto. Hay dos opciones de generación: eh, utilizando el
+
+00:01:38.280 --> 00:01:47.880
+mismo code para crearlo o una configuración manual. Yo voy a elegir la segunda. Hay que darle un nombre único. En este caso, voy a
+
+00:01:47.880 --> 00:01:57.240
+decirle que se va a llamar Architect. ¿Por qué? Porque va a actuar como un arquitecto de software especialista en definir cuáles son las fases
+
+00:01:57.240 --> 00:02:06.540
+que se deben cumplir para implementar el feature de rating. Así que lo llamaré Architect. Luego, me pide un system prompt. En este caso, yo
+
+00:02:06.540 --> 00:02:14.940
+voy a dejar aquí simplemente un mensaje inicial básico de system prompt, porque yo ya tengo un prompt preparado que voy a explicar más adelante.
+
+00:02:14.940 --> 00:02:26.860
+Pero, por ahora, basta con decir un system prompt o cualquier prompt, no importa. Luego, me pregunta en qué casos Claude debería, eh, usar este
+
+00:02:26.860 --> 00:02:35.880
+agente. También lo voy a dejar vacío, puede ser en cualquier caso. Ya luego lo modificaremos. Aquí me va a mostrar cuáles son las herramientas
+
+00:02:35.880 --> 00:02:44.320
+que yo quiero permitirle a este agente que puedo utilizar. Y tengo un, una amplia gama de herramientas que yo quiero utilizar o no. En
+
+00:02:44.320 --> 00:02:51.700
+este caso, a mí me, me interesa que pueda leer. Eh, o bueno, que sea read only. Eh, no quiero que sea read only, aunque
+
+00:02:51.700 --> 00:03:00.400
+lo podría seleccionar. ¿Sí? Por defecto están todas las herramientas. Quiero que ejecute otras tools. Sí, quiero que edite, sí. Y vamos a ver cuáles
+
+00:03:00.400 --> 00:03:09.540
+son las opciones avanzadas. En este caso, se trata más de cuáles son las herramientas individuales que podría utilizar. Eh, por ejemplo, ejecutar comandos en
+
+00:03:09.540 --> 00:03:19.480
+Bash, poder hacer un grep, poder leer, poder editar, poder editar múltiples veces, etcétera. Entonces, me interesa que todo esto esté disponible para el agente,
+
+00:03:19.480 --> 00:03:27.840
+aunque si necesito un caso particular, podría restringir, eh, cuáles son las herramientas a las que accede. Luego me pide cuál es el modelo. Hay
+
+00:03:27.840 --> 00:03:36.799
+modelos especialistas en ciertas cosas. Por ejemplo, Sonnet es muy bueno para la mayoría de las tareas. Opus es muy bueno haciendo, eh, tareas de
+
+00:03:36.800 --> 00:03:45.650
+razonamiento complejo. Haiku es muy eficiente para tareas simples o simplemente podemos elegir el mismo modelo que estamos teniendo en la conversación. Yo voy a
+
+00:03:45.650 --> 00:03:54.080
+elegir el número cuatro. Y luego un color. Esto sí es más como para identificar visualmente cuál es el agente que está corriendo. Yo lo
+
+00:03:54.080 --> 00:04:04.020
+voy a dar amarillo. Muy bien. ¿Qué significa esto? Eh, que ya tengo el agente prácticamente creado, pero me está dando un warning de que
+
+00:04:04.020 --> 00:04:10.140
+el system prompt está muy corto. Y está bien porque yo lo quiero así, porque yo luego lo voy a modificar. Le voy a decir
+
+00:04:10.140 --> 00:04:22.300
+que enter. Bien. Vemos que aquí ya me aparece el, el subagente de architect. Pero todo esto está siendo guardado en la carpeta Cloud, en
+
+00:04:22.300 --> 00:04:33.320
+la carpeta Agents. Y aquí está la definición del agente architect que yo tengo en el proyecto. Vamos a poner esto un poco más grande.
+
+00:04:33.320 --> 00:04:40.760
+Y aquí está. Este es el archivo markdown con la definición del subagente de architect. Vemos que está el system prompt, en este caso uno
+
+00:04:40.760 --> 00:04:50.460
+básico que pusimos genérico para ejemplificar cómo crearlo. Y está el yaml front matter, que es la, eh, configuración que se le da al subagente
+
+00:04:50.460 --> 00:04:59.160
+de cómo se va a comportar. En este caso, el nombre, la descripción, el modelo y el color. Esta descripción nosotros la pusimos como ejemplo,
+
+00:04:59.160 --> 00:05:06.539
+pero en verdad es muy mala para describir qué es lo que debe hacer este subagente. Yo tengo una descripción preparada en la que se
+
+00:05:06.540 --> 00:05:18.460
+indica qué es el caso en el que este subagente tiene sentido utilizarse. Y aquí estoy especificando que es un especialista en arquitectura de software,
+
+00:05:18.460 --> 00:05:30.080
+diseño de sistemas y análisis técnico profundo. Ahora, el system prompt. Este system prompt tampoco muestra bien qué es lo que debe hacer este subagente.
+
+00:05:30.080 --> 00:05:39.220
+Yo tengo preparado por acá un prompt mucho más específico y claro sobre cuáles son las tareas que debe cumplir este subagente. Vamos a leerlo.
+
+00:05:39.220 --> 00:05:46.500
+Muestra primero que es un especialista en arquitectura de software, muy similar a lo que está en la descripción. Le dice que es un arquitecto
+
+00:05:46.500 --> 00:05:55.310
+de software especializado en... Le dice cuáles son los ítems en los que está especializado, cuáles son sus responsabilidades, cuál es el contexto del proyecto,
+
+00:05:55.310 --> 00:06:03.940
+que esto es bastante importante que conozca sobre qué está trabajando, cuál es la metodología de análisis, cuáles son las instrucciones de trabajo y, por
+
+00:06:03.940 --> 00:06:11.220
+último, cuál es el formato de salida que va a dar este agente a su tarea. Y, en este caso, es un formato markdown, en
+
+00:06:11.220 --> 00:06:19.864
+el que decimos cuál es el análisis técnico de cierto feature.¿Bien? Cuál es el problema que se identifica, el impacto, la propuesta de solución y
+
+00:06:19.864 --> 00:06:27.662
+el plan de implementación. Muy bien, esto es todo lo que se necesita para un subagente. Lo guardamos y volvemos a la conversación que teníamos
+
+00:06:27.664 --> 00:06:36.282
+con Claude. Para esto, tenemos que reiniciar por completo a Claude, porque si no, no va a tomar el cambio que tenemos en el prompt
+
+00:06:36.284 --> 00:06:46.443
+del agente. Entonces, vamos a abrir Claude, le damos resume. Escogemos cuál es el, eh... la conversación que teníamos, que en este caso es la
+
+00:06:46.443 --> 00:06:54.904
+que habíamos hecho con los features de thinking y ahora vamos a invocar a este subagente. ¿Cómo se hace? Se puede hacer con el arroba.
+
+00:06:54.904 --> 00:07:03.364
+Y le decimos architect. Aquí se pone en amarillo porque fue el color que nosotros le dimos. Si presionamos tabulador, se va a poner en
+
+00:07:03.364 --> 00:07:12.823
+el contexto de la conversación que estamos invocando a este agente arquitecto y podemos darle una especificación en el que le podemos decir: «Utiliza el
+
+00:07:12.823 --> 00:07:31.284
+contexto que tenemos en la conversación para, eh, el análisis del impacto que debes hacer. Apóyate en lo que ya está descubierto y crea el
+
+00:07:31.284 --> 00:07:44.164
+plan de implementación». Excelente. Vemos que aquí se pone en amarillo y el nombre del ar-- del subagente está resaltado. Esto lo que significa es
+
+00:07:44.164 --> 00:07:54.864
+que está trabajando dentro del contexto del subagente de architect. Está haciendo todo el análisis inicial del proyecto, está utilizando el contexto que ya teníamos
+
+00:07:54.864 --> 00:08:03.984
+en la conversación y, como resultado final, va a ver el plan de implementación. Vemos que ya terminó la ejecución del subagente de arquitecto con
+
+00:08:03.984 --> 00:08:13.183
+estos resultados. Dice que ha creado un plan de implementación técnicamente sólido y detallado que aprovecha completamente el contexto del proyecto Platzi Flix. Y aquí
+
+00:08:13.183 --> 00:08:27.544
+tiene los aspectos destacados del plan: arquitectura sólida, performance, testing y escalabilidad. Algo que es importante es que el resultado de estos subagentes estén documentados
+
+00:08:27.544 --> 00:08:35.843
+dentro del mismo proyecto. Y yo le voy a indicar a Claude Code que el análisis que hizo me lo dé con el formato requerido
+
+00:08:35.843 --> 00:08:49.684
+que tiene el architect dentro de un archivo puntual en el proyecto. Esto se logra muy fácilmente diciéndole: ahora guarda, utilizando el formato que tiene
+
+00:08:49.684 --> 00:09:11.104
+el subagente de architect, el plan de implementación dentro de el proyecto. Guárdalo en una carpeta en el root que se llame spec y dale
+
+00:09:11.104 --> 00:09:35.304
+un nombre adecuado con esta nomenclatura. Eh... Cero, cero, nombre del spec.markdown. Cero, cero, es un número que incrementará a lo largo que se creen
+
+00:09:35.304 --> 00:09:43.064
+más specs. Bien, aquí yo le estoy diciendo que todo lo que investigó y el plan que creó, lo guarde dentro de un archivo en
+
+00:09:43.064 --> 00:09:51.124
+una carpeta específica. Y aquí le voy a decir que sí, que cree la carpeta spec. Muy bien, aquí vemos que este es el resultado
+
+00:09:51.124 --> 00:10:00.064
+de la investigación que tuvo el subagente sobre cómo implementar el sistema de ratings para Platzi Flix. Vemos cuáles fueron los patrones que identificó, cuál
+
+00:10:00.064 --> 00:10:08.223
+es la arquitectura de datos actual, es decir, estaba documentando a la vez que estamos creando, eso es superimportante. Y está el plan de implementación
+
+00:10:08.223 --> 00:10:15.464
+por fases y aquí me dice que hay fase uno, que es, eh, la modificación de la capa de base de datos. Dice que es
+
+00:10:15.464 --> 00:10:25.364
+crítica porque es la base de todo el sistema. Me parece importante. Cómo hacerlo y qué hacer. Excelente. Luego, las consideraciones técnicas, el performance, que
+
+00:10:25.364 --> 00:10:35.243
+es crear índices para que las queries no sean tan lentas. Esto me parece excelente, eh, porque ya está identificando paso a paso cómo vamos
+
+00:10:35.243 --> 00:10:48.294
+a hacer la implementación de este feature. No únicamente crearlo y ya, sino hacer por fases e inteligentes, secuenciales e incrementales la implementación. Le voy
+
+00:10:48.294 --> 00:10:59.064
+a dar a aceptar y eso significa que dentro de spec, en la carpeta spec, ya existe un archivo markdown con la especificación de qué
+
+00:10:59.064 --> 00:11:08.064
+es lo que debemos hacer para poder hacer la implementación de este feature. Este subagente de architect no solamente, eh, puede ser utilizado para crear
+
+00:11:08.064 --> 00:11:16.644
+features, sino también, por ejemplo, para hacer el análisis de un feature ya existente y, por ejemplo, indicarle: hay un bug que se debe mejorar
+
+00:11:16.644 --> 00:11:28.503
+y también hace toda esta planificación para mejorar el bug. Los subagentes son herramientas superpoderosas. Se pueden crear muchísimos que tengan una personalidad distinta dependiendo
+
+00:11:28.503 --> 00:11:36.164
+del caso de uso. El architect era el que necesitábamos para este caso. En las próximas clases vamos a utilizar este plan de implementación que
+
+00:11:36.164 --> 00:11:41.743
+creó el subagente de architect para hacer la implementación en el código del feature de ratings.
+

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/08-Actualización de Claude Code a versión 20 y mejoras de Sonnet 45.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8f8c76a2f31f06e68ce1c00998ca20c892fab3bdc3b7f55dfad25b6ddecd6a48
+size 129969356

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/08-Actualización de Claude Code a versión 20 y mejoras de Sonnet 45.vtt

@@ -0,0 +1,179 @@
+WEBVTT
+
+00:00:00.120 --> 00:00:07.540
+En las clases anteriores aprendimos los features de modos de pensamiento extendido y también sobre cómo crear subagentes en Cloud Code. En el mundo de
+
+00:00:07.540 --> 00:00:15.380
+AI, es frecuente que las empresas hagan lanzamientos con mejoras incrementales. En esta clase, vamos a aprender cómo actualizar Cloud Code a su versión dos
+
+00:00:15.380 --> 00:00:23.460
+y qué features nuevos tiene Cloud Sonnet 4.5 que nos van a ayudar en la mejora del flujo de programación. Vamos al editor. La actualización
+
+00:00:23.460 --> 00:00:32.460
+de Cloud Code no únicamente fue dentro del CLI, sino que también se actualizó el plugin para Visual Studio Code. Entonces, vamos por partes. Lo
+
+00:00:32.460 --> 00:00:42.480
+primero que vamos a actualizar es el CLI. Para hacerlo, tenemos que escribir, eh, cloud seguido del comando update. Aquí, automáticamente va a revisar cuál
+
+00:00:42.480 --> 00:00:50.360
+es la última versión disponible, cuál es la versión actual y va a actualizarla con la que está más reciente. En este caso, ya estaba,
+
+00:00:50.360 --> 00:00:57.120
+ah, actualizado, por lo que no hubo un cambio. Si lo actualizas de la versión uno a la versión dos, sí va a haber una,
+
+00:00:57.120 --> 00:01:05.740
+una serie de modificaciones más importantes que este mensaje. Para el plugin, tenemos que irnos a la lista de plugins, buscar cloud y hacer clic
+
+00:01:05.740 --> 00:01:13.700
+en este para hacer la actualización. En este caso, ya también está actualizado y pomo-- podemos ver que está en la versión 2.0.14, que es
+
+00:01:13.700 --> 00:01:25.140
+la misma que tenemos en el CLI. ¿Qué es lo más relevante visualmente? Que Cloud Code ya, cuando activamos el plugin, no es una interfaz
+
+00:01:25.140 --> 00:01:34.100
+de CLI que está corriendo en el editor, sino que ya es una versión gráfica que ya está renderizando muchos más componentes respecto a la
+
+00:01:34.100 --> 00:01:44.520
+versión anterior. Esto es una mejora visual, pero también por detrás tiene mejoras en el comportamiento de Cloud Code. Voy a hacer también el demo,
+
+00:01:44.520 --> 00:01:52.860
+ah, utilizando el CLI. ¿Por qué? Porque también cambió la, la forma en la que se trabaja con el CLI y siguen siendo útiles ambas
+
+00:01:52.860 --> 00:02:01.480
+partes, tanto usarlo dentro del editor como utilizarlo dentro de la terminal. ¿Qué es lo más relevante que hizo el equipo de Anthropic en el
+
+00:02:01.480 --> 00:02:10.780
+lanzamiento de Cloud Code 2.0? Implementó el sistema de checkpoints, que es la forma en la que cuando Cloud Code está escribiendo código que nosotros
+
+00:02:10.780 --> 00:02:20.500
+no esperamos como programadores, podemos detener la ejecución y volver al punto de partida que empezó Cloud Code escribiendo ese código. Esto sin necesidad de
+
+00:02:20.500 --> 00:02:26.720
+tener git, un commit o un app a, a los cambios que se han hecho, sino que Cloud Code ya lo tiene integrado dentro de
+
+00:02:26.720 --> 00:02:34.520
+su sistema. Podemos hacer una demostración pequeña de una modificación que le vamos a pedir a Cloud Code de ejemplo y retornar al punto de
+
+00:02:34.520 --> 00:02:53.180
+partida. Entonces, podemos decir: en el archivo, eh, cero, cero, eh... sistema de ratings, agrega un... una parte en la que expliques cómo funciona un
+
+00:02:53.180 --> 00:03:08.710
+LLM. Aquí le vamos a dar el disclaimer de que debe ser un ejemplo corto para, eh, demostrar que es un LLM. Okey. Aquí va
+
+00:03:08.710 --> 00:03:18.000
+a empezar, al igual que la versión uno de Cloud Code, a leer el archivo, está pensando sobre cómo hacer la ejecución de esto y
+
+00:03:18.000 --> 00:03:27.880
+luego va a agregar la sección. Aquí ya también vemos diferencias con la forma en la que se estaba mostrando la versión anterior con esta.
+
+00:03:27.880 --> 00:03:36.260
+Por ejemplo, si queremos ver el pensamiento, tenemos que escribir control O. Y aquí ya vemos qué es el razonamiento que le está teniendo con
+
+00:03:36.260 --> 00:03:43.820
+respecto al-- la modificación que yo le estoy diciendo. Para cerrarlo también, con conan-- con control O se puede cerrar. Y aquí ya me hizo
+
+00:03:43.820 --> 00:03:52.660
+un apéndice. Entonces, en una demostración pequeña yo le voy a decir que sí. Muy bien. [inspira] Aquí ya está terminando de hacer la, la
+
+00:03:52.660 --> 00:04:02.520
+ejecución de lo que le solicité. Eh, me está diciendo que estaba pensando. Muy bien, ahora, ¿cómo yo veo y cómo retorno al punto anterior?
+
+00:04:02.520 --> 00:04:10.880
+Presiono dos veces escape. Con escape yo voy a ver que aquí hay la instrucción que yo le di hace rato y la instrucción que
+
+00:04:10.880 --> 00:04:19.820
+está actualmente sucediendo. Si yo quiero retornar a este punto, lo selecciono con la flecha y presiono enter. En este punto, él me va a
+
+00:04:19.820 --> 00:04:28.700
+dar la opción, si quiere que restaure el código y la conversación, si solo quiere que restaure la conversación o si solo quiero que restaure
+
+00:04:28.700 --> 00:04:35.539
+el código. Entonces, con esas tres opciones nosotros podemos elegir cuál es el comportamiento que queremos. Yo lo que quiero en este caso es demostrar
+
+00:04:35.540 --> 00:04:43.280
+que se puede restaurar el código y la conversación. Entonces, la opción uno. ¿Qué va a pasar acá? Que ya los cambios que nosotros teníamos
+
+00:04:43.280 --> 00:04:53.060
+dentro del archivo cero cero ya no están. Ya no está el apartado de LLMs como le habíamos pedido, porque se borraron cuando le solicitamos
+
+00:04:53.060 --> 00:05:03.320
+que, eh, revertiera los cambios. Excelente. Este es el primer paso o este es el primer gran cambio que tiene Cloud Code 2.0. Lo siguiente
+
+00:05:03.320 --> 00:05:11.380
+es que nosotros vimos en las clases anteriores los modos de pensamiento. En las clases anteriores aprendimos que para activar los modos de pensamiento debíamos
+
+00:05:11.380 --> 00:05:20.400
+escribir las palabras think o think deeply. Ya esto no ocurre en Cloud Code 2.0, sino que el modo de pensamiento se activa presionando la
+
+00:05:20.400 --> 00:05:29.640
+tecla tabulador. Aquí, cuando lo presionamos, se nos muestra que el modo de pensamiento está pre-encendido o apagado, como lo vemos acá. Lo que sí
+
+00:05:29.640 --> 00:05:39.880
+sigue existiendo es el feature de que se piense en el modo ultra think. Aquí ya vemos que se prende con estos colores y eso
+
+00:05:39.880 --> 00:05:47.440
+significa que Cloud Code lo que va a hacer es pensar muchísimo más allá en su modo de pensamiento extendido sobre cómo implementar lo que
+
+00:05:47.440 --> 00:05:56.140
+se le está solicitando. Pero se simplificó eh, presionando la tecla tabulador para activar los modos de pensamiento.Cloud Code ahora es capaz de poder ejecutar
+
+00:05:56.140 --> 00:06:04.660
+tareas por treinta horas consecutivas. Esto no se debe únicamente a una mejora en la forma en la que actúan sus agentes internos, sino también
+
+00:06:04.660 --> 00:06:12.940
+por el modelo de Sonnet 4.5. Podemos ver que aquí en este blog post están los benchmarks que el equipo de Anthropic hace con respecto
+
+00:06:12.940 --> 00:06:24.220
+al resto de modelos existentes. Por ejemplo, comparan con el mismo Opus 4.1, Sonnet 4 y con modelos como GPT5 Codex, GPT5 y Gemini 2.5
+
+00:06:24.220 --> 00:06:34.120
+Pro. En esta prueba controlada con una muestra de quinientas, eh, ejecuciones, podemos ver que Sonnet 4.5 fue sustancialmente mejor que el resto de modelos.
+
+00:06:34.120 --> 00:06:42.200
+En el blog post, también el equipo de Anthropic explica por qué este modelo ahora es capaz de poder ejecutar tareas con treinta horas de
+
+00:06:42.200 --> 00:06:52.360
+duración sin perder contexto y manteniendo una mejora sustancial en la memoria que tiene este modelo. Entonces, es muy interesante lo que explica aquí el
+
+00:06:52.360 --> 00:06:58.960
+equipo de Anthropic. Se los dejo de lectura para que vean cuál es el nuevo capability que tiene este modelo. Otra de las mejoras que
+
+00:06:58.960 --> 00:07:08.600
+tiene Cloud Code versión dos, ahora es un comando que se llama usage. Vamos al editor. El comando usage me muestra información importante sobre mi
+
+00:07:08.600 --> 00:07:17.230
+sesión actual de trabajo con Cloud Code, cuánto he utilizado de mi límite y cuándo se resetea según mi zona horaria. Este comando solo está
+
+00:07:17.230 --> 00:07:25.460
+disponible para cuando se utiliza Cloud Code con la suscripción de Anthropic, no cuando se está utilizando los tokens de la consola, por ejemplo, cuando
+
+00:07:25.460 --> 00:07:33.820
+una empresa da acceso a sus colaboradores para trabajar con los tokens de Cloud Code. Otra mejora que está ahora incluida en el CLI es
+
+00:07:33.820 --> 00:07:43.620
+poder hacer una búsqueda recursiva sobre el historial de prompts. Y esto se activa presionando la tecla Control R. Aquí nos va a salir una
+
+00:07:43.620 --> 00:07:50.600
+especie de buscador en el que podemos dar un indicio de qué fue lo que nosotros escribimos en ese prompt. Por ejemplo, hace un rato
+
+00:07:50.600 --> 00:07:58.140
+nosotros le pedimos que hiciera un ejemplo de qué es un LLM. Entonces, si yo escribo aquí la palabra «un LLM», va a pasar que
+
+00:07:58.140 --> 00:08:05.080
+le encuentra que yo le pedí ese prompt. Esto es útil para cuando quieres buscar un prompt que fue utilizado anteriormente y traerlo a esta
+
+00:08:05.080 --> 00:08:13.679
+nueva conversación. De esta forma, yo podría darle enter y de nuevo se hace la ejecución de este prompt con lo que le solicité. Igual,
+
+00:08:13.680 --> 00:08:21.500
+se puede interrumpir la ejecución con la tecla escape. Todos los conceptos y fundamentos que aprendimos en las clases anteriores siguen siendo útiles con esta
+
+00:08:21.500 --> 00:08:28.700
+utilización de Cloud Code y se potencian con el lanzamiento de Sonnet 4.5. En la sección de enlaces, deje uno en el que puedes ver
+
+00:08:28.700 --> 00:08:36.740
+el changelog de Cloud Code 2.0 para que puedas ver todos los features adicionales a los que ya presenté que están en este nuevo lanzamiento.
+
+00:08:36.740 --> 00:08:38.180
+Vamos a la siguiente clase.
+

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/08-Lecturas recomendadas.txt

@@ -0,0 +1,5 @@
+https://www.anthropic.com/news/claude-sonnet-4-5
+https://www.anthropic.com/news/enabling-claude-code-to-work-more-autonomously
+https://www.anthropic.com/engineering/building-agents-with-the-claude-agent-sdk
+https://marketplace.visualstudio.com/items?itemName=anthropic.claude-code
+https://www.anthropic.com/news/enabling-claude-code-to-work-more-autonomously

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/09-Creación de subagentes especializados en Claude Code.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:139faee5c3cee53d3850fe02ed36e229b21a85d8320692fd26ba242c7fe9fa1a
+size 133010602

Curso de Claude Code/01-Módulo 1 DiscoveryAnálisisPlanning/09-Creación de subagentes especializados en Claude Code.vtt

@@ -0,0 +1,158 @@
+WEBVTT
+
+00:00:00.060 --> 00:00:08.580
+El subagente arquitecto hizo un plan de implementación a alto nivel para hacer el features de rating en nuestra base de código. En esta clase
+
+00:00:08.580 --> 00:00:18.140
+vamos a aprender cómo crear subagentes especializados para frontend y backend y cómo orquestar su ejecución en paralelo utilizando Cloud Code. Vamos al editor. Los
+
+00:00:18.140 --> 00:00:28.140
+agentes de Cloud están dentro de la carpeta agents en la carpeta punto Cloud. Ya tenemos específico el comportamiento del subagente de arquitecto y el
+
+00:00:28.140 --> 00:00:37.600
+resultado de la ejecución que tuvimos en las clases anteriores fue este resumen sobre cómo es o cómo debe ser la implementación del sistema de
+
+00:00:37.600 --> 00:00:47.140
+ratings para Platiflix, que es nuestra base de código. Vemos que el alcance está para backend y para frontend. Ahora, lo que vamos a hacer
+
+00:00:47.140 --> 00:00:56.280
+es crear dos nuevos subagentes: el subagente de backend y el subagente de frontend. Para crear un subagente, recordemos que tenemos el comando agents dentro
+
+00:00:56.280 --> 00:01:03.820
+del Cloud Code con el que podemos darle instrucciones paso a paso a Cloud para que nos ayude creando el subagente. En este caso, yo
+
+00:01:03.820 --> 00:01:11.860
+ya tengo los dos prompts para el subagente de backend y de frontend creados. Entonces, lo que vamos a hacer es únicamente crear dos archivos:
+
+00:01:11.860 --> 00:01:27.420
+backend.markdown y frontend.markdown. Para el agente de frontend vemos que la especificación del prompt es que es un especialista en desarrollo frontend y explica bien
+
+00:01:27.420 --> 00:01:38.040
+cuál es el stack técnico que tiene este proyecto: Next, React, TypeScript, etcétera. Vemos que explica también cuáles son las responsabilidades específicas que tiene este
+
+00:01:38.040 --> 00:01:47.520
+subagente en este proyecto y cuál es el contexto. Entonces, la lógica detrás de este subagente es dar una explicación o un contexto desde lo
+
+00:01:47.520 --> 00:01:56.380
+más general a lo más específico, desde el estado del arte de cómo es el stack técnico de este proyecto a qué es lo que
+
+00:01:56.380 --> 00:02:04.640
+se debe encargar en la ejecución de este proyecto. Y para el backend es muy similar. Lo único que cambia es que claramente, eh, se
+
+00:02:04.640 --> 00:02:15.280
+utiliza, eh, FastAPI, Python y SQLAlchemy, y va desde lo más general a lo más específico. Vamos a utilizar estos dos subagentes e invocarlos de
+
+00:02:15.280 --> 00:02:25.380
+forma implícita. Esto significa que le vamos a pedir al Cloud Code que sea él quien los invoque para cierta tarea. En Cloud Code podemos
+
+00:02:25.380 --> 00:02:34.820
+hacer la invocación de subagentes de forma explícita o implícita. La forma explícita es haciendo arroba, seguido de la palabra agent, y aquí nos van
+
+00:02:34.820 --> 00:02:43.380
+a aparecer cuáles son los agentes que tenemos disponibles. Vemos que se lista el frontend, el backend y el architect. Y la forma implícita es
+
+00:02:43.380 --> 00:02:53.680
+hacerlo a través del prompt. Entonces, en este prompt vamos a pedir que analice el resultado de la clase anterior, que fue el cero cero
+
+00:02:53.680 --> 00:03:04.519
+sistema ratings cursos, que fue el resultado del análisis de arquitectura del subagente arquitecto. A partir de este contexto, que cree un plan de implementación
+
+00:03:04.520 --> 00:03:13.220
+para backend y para frontend utilizando estos dos subagentes de forma paralela. Eso lo podemos escribir en el mismo prompt que le damos a Cloud
+
+00:03:13.220 --> 00:03:30.580
+Code. Analiza el cero cero sistema ratings de cursos, que es el análisis que hizo tu subagente de arquitecto. Utilizando esto como referencia, utiliza a
+
+00:03:30.580 --> 00:03:52.480
+los subagentes de backend y de frontend para crear un plan específico de implementación. No generes código, sino que crea únicamente las fases que se
+
+00:03:52.480 --> 00:04:01.500
+harán en la implementación. Aquí vemos que Cloud Code fue capaz de invocar a los dos subagentes para que haga su ejecución en paralelo. Y
+
+00:04:01.500 --> 00:04:09.240
+aquí vemos que lo que hace Cloud es enviar un prompt creado por él mismo para que el subagente se encargue de la ejecución de
+
+00:04:09.240 --> 00:04:16.719
+este prompt. Vemos que aquí Cloud nos dice que podemos utilizar control T para mostrar cuáles son la lista de to dos que él tiene
+
+00:04:16.720 --> 00:04:24.040
+en este momento. Si lo presionamos, vemos que para cada uno de ellos hay un to do y, una vez que lo completa, lo tacha
+
+00:04:24.040 --> 00:04:32.520
+y lo marca como hecho. Lo podemos ocultar y él va a seguir con su implementación. Este es el plan de implementación de frontend creado
+
+00:04:32.520 --> 00:04:41.000
+por el subagente especialista en frontend. Lo que vemos es que primero hace un contexto del proyecto analizando cuál es la arquitectura actual, cuál es
+
+00:04:41.000 --> 00:04:50.120
+la estructura de componentes que tiene este, eh, proyecto y además cuáles son los patrones de desarrollo. Luego, empieza explicando cuáles son las fases de
+
+00:04:50.120 --> 00:05:00.400
+implementación. Primero, las nuevas interfaces para rating, cuáles son los, eh, nuevos tipos o interfaces que necesita crear para soportar los ratings, cuáles son las
+
+00:05:00.400 --> 00:05:08.620
+consideraciones en las cuales tiene que estar consciente al momento de implementarlo y así sucesivamente. Lo que podemos ver es que las fases de implementación
+
+00:05:08.620 --> 00:05:17.060
+tienen sentido y que cumplen con lo que nosotros le estamos pidiendo, que es la implementación del sistema de ratings. Entonces, yo voy a decir
+
+00:05:17.060 --> 00:05:27.100
+que sí quiero que haga esta edición sobre este archivo. Y, luego, ya terminó también el subagente de backend y vemos que está haciendo un
+
+00:05:27.100 --> 00:05:37.160
+análisis muy similar. Primero, cuáles son los patrones identificados en el código actual, hace la estructura actual de directorios de este, eh, base de código
+
+00:05:37.160 --> 00:05:45.080
+para el backend y también las fases de implementación. Primero, la base de datos, que es lo esperado. Primero tenemos que crear las migraciones de
+
+00:05:45.080 --> 00:05:52.660
+la base de datos. Eso también lo dijo el subagente de arquitecto, que hay que empezar con lo más importante o lo más fundamental, que
+
+00:05:52.660 --> 00:06:05.200
+es la base de datos. También está considerando los comandos que necesita ejecutar para agregar las migraciones, la estructura de la migración.[comunicación cruzada] Y también, eh,
+
+00:06:05.200 --> 00:06:14.620
+continúa explicando qué es lo que debe hacer, por ejemplo, si necesita hacer un rollback, que es el downgrade de este comando. Y así sucesivamente.
+
+00:06:14.620 --> 00:06:24.840
+Como tiene sentido, yo también voy a aceptar este plan de implementación para backend. Muy bien. Aquí me está dando un pequeño resumen que es
+
+00:06:24.840 --> 00:06:32.900
+que el plan es cien por ciento implementable de forma secuencial. Cada fase puede ejecutarse independientemente. Y el documento no contiene código, que fue lo
+
+00:06:32.900 --> 00:06:43.200
+que nosotros le pedimos al inicio. Solo especificaciones detalladas de qué y cómo debe implementarse. Muy bien. Estos dos archivos están viviendo dentro de la
+
+00:06:43.200 --> 00:06:53.039
+carpeta de spec y vemos que tienen un nombre particular: backend ratings y frontend ratings. Entonces, lo que podemos hacer es, eh, cambiarle la numeración,
+
+00:06:53.039 --> 00:06:59.530
+por ejemplo, para que el backend sea la fase dos o el spec número dos y el backend sea el número uno. De esta forma,
+
+00:06:59.530 --> 00:07:07.200
+pusimos a dos subagentes a ejecutarse en paralelo. El número de subagentes no es limitado a que sean solo dos, sino que pueden haber varios
+
+00:07:07.200 --> 00:07:14.820
+ejecutándose en paralelo. Cada subagente tiene un contexto de ejecución aislado del resto y que eso lo podemos ver con el comando de context. Vamos
+
+00:07:14.820 --> 00:07:24.280
+al editor. Con context, él lo que nos va a decir es cómo los subagentes están utilizando la memoria del contexto de esta conversación. Vemos
+
+00:07:24.280 --> 00:07:34.120
+que el system prompt está ocupando dos punto dos mil tokens y que cada uno de los-- eh, las herramientas de este sistema, también los
+
+00:07:34.120 --> 00:07:45.200
+MCPS, están consumiendo tokens. Y acá abajo podemos ver cuál es la cantidad de tokens que está utilizando cada agente personalizado de este proyecto. A
+
+00:07:45.200 --> 00:07:54.530
+medida que va incrementando la ejecución de los agentes o cualquier ejecución, vamos a ver que se incrementa el número de tokens para esta conversación.
+
+00:07:54.530 --> 00:08:03.380
+Con estos dos planes de implementación ya podemos ir a la creación de código. Recordemos que todas estas fases preliminares fue para hacer un análisis
+
+00:08:03.380 --> 00:08:11.929
+intensivo de la base de código existente, la planificación de la ejecución y ahora sí podemos ver los resultados en código propiamente. Nos vemos en
+
+00:08:11.929 --> 00:08:12.859
+la próxima clase.
+

Curso de Claude Code/02-Módulo 2 Implementación Backend/01-Uso de unit tests para migraciones seguras de base de datos.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8ab7a806ad38057b87dcc6bbe5dc26335e2b69a82986aff9809953ccdb641e1
+size 185985044

Curso de Claude Code/02-Módulo 2 Implementación Backend/01-Uso de unit tests para migraciones seguras de base de datos.vtt

@@ -0,0 +1,221 @@
+WEBVTT
+
+00:00:00.140 --> 00:00:07.340
+Para hacer la migración de base de datos de esta base de código, necesitamos garantizar que funcione. Los unit tests son la herramienta que vamos
+
+00:00:07.340 --> 00:00:14.979
+a utilizar para esto. Antes de avanzar, te invito a que utilizando Cloud Code, puedas analizar y solucionar el error que está sucediendo actualmente en
+
+00:00:14.980 --> 00:00:30.010
+este sistema con los unit tests. Déjame la solución en la sección de comentarios. El problema es que para ejecutar los unit tests eran necesarias
+
+00:00:30.010 --> 00:00:42.740
+estas dos dependencias: httpx y pytest-asyncio. Agregándolas a las dependencias opcionales de este proyecto y luego construyendo UV, era suficiente para que los tests se
+
+00:00:42.740 --> 00:00:49.360
+pudieran ejecutar. Y esta es la solución al reto que te dejé hace un momento. En el plan de implementación vemos que están muy bien
+
+00:00:49.360 --> 00:00:58.240
+definidas cuáles son las fases existentes y cuáles son los checklists que se deben cumplir para garantizar que se terminó esa fase. La primera es
+
+00:00:58.240 --> 00:01:05.400
+la de base de datos. Y como dijimos hace un rato, lo que tenemos que garantizar, que el sistema esté corriendo a través de los
+
+00:01:05.400 --> 00:01:15.760
+unit tests. Entonces, abrimos Cloud Code y le vamos a pedir que ejecute el unit test dentro del contenedor. El prompt es bastante sencillo y
+
+00:01:15.760 --> 00:01:30.440
+lo que se le va a decir es que: ejecuta el comando de pytest dentro del contenedor de API para garantizar que el servicio esté
+
+00:01:30.440 --> 00:01:40.780
+funcionando. Muy bien, excelente. Aquí nos dice que va a ejecutar un comando que es docker compose utilizando el tool de Bash. Este tool de
+
+00:01:40.780 --> 00:01:48.760
+Bash ya es uno de los que trae por defecto Cloud Code y lo que permite es ejecutar comandos como si fuera la terminal. Y
+
+00:01:48.760 --> 00:02:00.800
+en este caso lo que está intentando es ejecutar el comando pytest dentro del contenedor de API. Y aquí, esta es el resultado de la
+
+00:02:00.800 --> 00:02:10.000
+ejecución del unit test dentro del contenedor que nosotros tenemos ejecutando en este momento. Vemos que hay pruebas como de traer todos los cursos, de
+
+00:02:10.000 --> 00:02:17.400
+traer una lista vacía, etcétera. Es decir, este es el, el set de pruebas que tiene este servicio y están corriendo al cien por ciento,
+
+00:02:17.400 --> 00:02:25.500
+como se puede ver acá. Entonces, ya que tenemos este contexto y sabemos que el servicio está funcional, vamos a pedirle que empiece con la
+
+00:02:25.500 --> 00:02:34.519
+implementación de la fase uno de esta especificación. Entonces, mencionamos el archivo cero uno y lo que vemos es que no está encontrando este plan
+
+00:02:34.520 --> 00:02:44.200
+de especificación. ¿Por qué? Porque si yo ejecuto acá, por ejemplo, el pwd, que es el comando para saber mi ubicación, veo que estoy dentro
+
+00:02:44.200 --> 00:02:54.380
+de la carpeta de backend. Y este archivo de especificación está por fuera de acá. Entonces, puedo utilizar el bash mode. El bash mode se
+
+00:02:54.380 --> 00:03:04.200
+activa utilizando el signo de exclamación. Y aquí yo puedo escribir comandos de bash que se van a ejecutar y que Cloud Code va a
+
+00:03:04.200 --> 00:03:14.640
+tener como contexto de su ejecución. Es decir, si yo necesito regresar una carpeta más arriba, puedo ejecutar este comando, podemos explicar pwd. Y aquí
+
+00:03:14.640 --> 00:03:20.680
+lo que me dice es que yo no puedo hacer esto. Entonces, le voy a pedir a Cloud Code que ejecute él el comando para
+
+00:03:20.680 --> 00:03:32.700
+ir a la carpeta de Cloud Code. Necesito estar en este directorio y no en backend. Entonces, veamos qué comando es el que él ejecuta
+
+00:03:32.700 --> 00:03:42.260
+para regresar, porque no me permitió hacer este que está acá. Entonces, veamos. Es prácticamente el mismo, pero dice que no puede. Entonces, vamos a
+
+00:03:42.260 --> 00:03:50.900
+ver cómo lo soluciona. A ver, pwd no funciona. En este caso, lo más sencillo es que nos salgamos de Cloud Code, hagamos nosotros la
+
+00:03:50.900 --> 00:03:58.300
+ejecución del comando fuera de Cloud Code y volvamos a empezar. Muy bien. Aquí se nos va a reiniciar la conversación, pero no pasa nada
+
+00:03:58.300 --> 00:04:09.980
+porque no habíamos hecho nada importante. Ahora sí lo podemos mencionar. Ocho uno backend. Empecemos la implementación de la fase uno de este plan. Es
+
+00:04:09.980 --> 00:04:22.580
+necesario que los comandos que vayas a ejecutar sean dentro del contenedor de API. ¿Por qué no? Porque es el lugar en el que está
+
+00:04:22.580 --> 00:04:37.239
+siendo ejecutado. Vamos a agregarle más contexto. En el archivo de Make hay varios comandos que resultarán útiles para poder re, eh, construir y reiniciar
+
+00:04:37.240 --> 00:04:45.100
+la imagen de Docker si es necesaria. Aquí, como es algo que yo quiero que sea muy bien ejecutado y bien planificado, yo lo voy
+
+00:04:45.100 --> 00:04:52.040
+a poner en plan mode. ¿Para qué? Para entender qué es lo que él va a hacer antes de ejecutarlo. ¿Cómo se cambia entre planes?
+
+00:04:52.040 --> 00:05:00.000
+Aquí lo dice muy bien con shift up. Entonces, existen varios tipos de, eh, modos de ejecución. Está el auto accept, que es que cualquier
+
+00:05:00.000 --> 00:05:06.780
+cosa que haga yo lo acepto por defecto. Está el plan mode, que es ver cómo él planifica la ejecución de esto. Y está el
+
+00:05:06.780 --> 00:05:12.800
+modo por defecto, que es que antes de avanzar me va a pedir confirmación. Lo vamos a poner en plan mode y le vamos a
+
+00:05:12.800 --> 00:05:20.670
+ejecutar. Aquí me pide entrar a la carpeta backend y ver cuáles son los contenedores que están corriendo en este momento. Aquí él ya tiene
+
+00:05:20.670 --> 00:05:28.420
+en su contexto la lista de contenedores de Docker que están siendo ejecutados. Y así él puede saber con cuál trabajar para ejecutar los comandos.
+
+00:05:28.420 --> 00:05:37.980
+Lo que vamos a darnos constantemente cuenta es que él va, busca contexto, se da cuenta de cosas y quiere ejecutar nuevos comandos. En este
+
+00:05:37.980 --> 00:05:46.920
+caso, lo que me está pidiendo es que entre la carpeta de backend y ejecute un comando dentro del contenedor de API, que es entrar
+
+00:05:46.920 --> 00:05:55.620
+a app y correr a Alembic para saber cuál es el estado actual de estas migraciones. Vamos a darle que sí. Aquí el problema es
+
+00:05:55.620 --> 00:06:04.392
+que él ya se había cambiado al directorio de backend en el paso anterior. Entonces, no, no existe en esta situación.[comunicación cruzada] Vuelves a mostrar el
+
+00:06:04.392 --> 00:06:12.751
+comando con las modificaciones. Le decimos que sí y me dice que ya tiene el contexto necesario para crear la migración de base de datos.
+
+00:06:12.751 --> 00:06:19.871
+El resultado del plan mode es este. Es una explicación un poco más específica de qué es lo que va a hacer antes de que
+
+00:06:19.871 --> 00:06:29.702
+lo ejecute. Entonces, entiende que el objetivo es crear la tabla de course rating en Postgres con los constraints, índices y migraciones Alembic correspondientes. Entonces,
+
+00:06:29.702 --> 00:06:37.852
+aquí entiende cuál es el contenedor que está corriendo, cuál es la migración actual [que es la última que se ejecutó] y un patrón de migración identificado. Entonces, ¿cuáles son los
+
+00:06:37.852 --> 00:06:46.871
+pasos que va a hacer? Crear la nueva migración, crear el archivo. Ejecutar la migración con el comando make que yo le di hace rato
+
+00:06:46.871 --> 00:06:58.871
+como contexto y va a verificar en Postgres si se ejecutó correctamente. Entonces, tenemos opciones. ¿Cómo esperamos que se ejecute? Automáticamente, aceptando las ediciones que
+
+00:06:58.871 --> 00:07:06.751
+haga. Otro paso es que yo manualmente apruebe las ediciones y, si no me gusta el plan, yo aquí le puedo decir cómo mejorar. En
+
+00:07:06.751 --> 00:07:11.712
+este caso, a mí me gustó y lo voy a auto-aceptar, así que presiono el número uno. Y él va a empezar a hacer su
+
+00:07:11.712 --> 00:07:20.442
+ejecución. Aquí vemos que cuando quiere hacer la ejecución de un comando de bash, él me pregunta si quiero proceder o no. Yo puedo confiar,
+
+00:07:20.442 --> 00:07:29.131
+en este caso, de que cualquier cosa que haga va a tener un impacto muy bajo. ¿Por qué? Porque va a ser ejecución sobre el
+
+00:07:29.131 --> 00:07:39.532
+docker compose, sobre una serie de contenedores que están corriendo de forma local. Así que yo en este momento voy a decirle que sí acepto
+
+00:07:39.532 --> 00:07:46.772
+que proceda y que no me vuelva a preguntar si quiere ejecutar el comando docker compose para este folder en particular. Le voy a decir
+
+00:07:46.772 --> 00:07:53.032
+que dos. Entonces, ya cada vez que él quiera ejecutar un comando de docker compose, no me va a preguntar. Cloud Code ya me está
+
+00:07:53.032 --> 00:07:59.371
+diciendo que terminó la ejecución de esta primera fase. Me dice que ya se ha completado exitosamente y aquí está el resumen de lo que
+
+00:07:59.371 --> 00:08:09.642
+hizo. Primero, creó el archivo de migraciones. Podemos ver lo que está acá. Y está... correcto. Dice que ya tiene la estructura de tabla según
+
+00:08:09.642 --> 00:08:18.631
+lo que estaba en la especificación. También me dice que se crearon los constraints, los índices, que se ejecutó la migración y ya está todo
+
+00:08:18.631 --> 00:08:30.352
+validado en Postgres. ¿Qué falta? Falta pedirle que actualice este plan de implementación y que los marque como completados. Nosotros tenemos que conectar a Cloud
+
+00:08:30.352 --> 00:08:37.952
+Code con el editor. Nosotros sabemos que ya está conectado porque aquí, en la parte de abajo, me muestra en cuál archivo estoy dentro del
+
+00:08:37.952 --> 00:08:48.541
+editor. Por ejemplo, si yo cambio de archivo, automáticamente se actualiza. Y yo puedo seleccionar esta, eh, todo este bloque de código y presiono las
+
+00:08:48.541 --> 00:09:01.692
+teclas command option K. Y aquí lo que me permite es poder mencionar cierto archivo en ciertas líneas y dárselo como contexto a Cloud Code.
+
+00:09:01.692 --> 00:09:12.771
+Y aquí le voy a decir: marca como finalizadas las tareas que ya lo están. Excelente. Vemos que Cloud Code ya hizo los checks o
+
+00:09:12.771 --> 00:09:22.712
+los agregó a aquellas tareas que ya terminó en su plan de ejecución. Nosotros ya podemos garantizar que esta fase de base de datos está
+
+00:09:22.712 --> 00:09:30.771
+culminada y certificada por el propio Cloud Code. Lo que le vamos a pedir es lo mismo que le pedimos al inicio, que es que
+
+00:09:30.771 --> 00:09:45.872
+ahora ejecute el unit test para garantizar que no hayamos dañado el servicio. Garantiza que el servicio sigue corriendo, volviendo a ejecutar los unit tests.
+
+00:09:45.872 --> 00:09:53.372
+Ya ejecutó los unit tests y se dio cuenta de que funciona correctamente, pero ahora él quiere hacer una validación adicional, que es ver si
+
+00:09:53.372 --> 00:10:00.551
+el endpoint de health que tiene este servicio funciona correctamente. Yo le voy a decir que sí, porque es algo importante que él se dé
+
+00:10:00.551 --> 00:10:09.891
+cuenta de que no es únicamente que los unit tests siguen corriendo, sino que el servicio entero siga funcionando. Entonces, aquí dice que está funcionando
+
+00:10:09.891 --> 00:10:18.752
+correctamente, pero va a hacer una verificación final de los endpoints principales. Entonces, lo que yo voy a hacer es permitirle que cualquier otro comando
+
+00:10:18.752 --> 00:10:27.992
+o ejecución de comando curl y de Python tres lo permita. De esta forma, ya Cloud Code pudo validar enteramente el funcionamiento de este servicio,
+
+00:10:27.992 --> 00:10:37.102
+no únicamente con unit tests, sino también con una especie de prueba de integración, haciendo llamados a los endpoints y revisando su respuesta. Vemos que
+
+00:10:37.102 --> 00:10:44.271
+también nos da un resumen bastante completo de, eh, qué fue lo que hizo. Dijo que los tests unitarios pasaron, que el estado del contenedor
+
+00:10:44.271 --> 00:10:51.692
+es que está activo y que también los endpoints están re-- eh, respondiendo correctamente. Ya terminamos la fase uno de implementación de los cambios en
+
+00:10:51.692 --> 00:11:00.012
+el backend. El reto es que ahora tú, utilizando Cloud Code, hagas la implementación de la fase dos, que es la creación de los modelos
+
+00:11:00.012 --> 00:11:06.271
+de SQLAlchemy. Déjame en la sección de comentarios qué retos tuviste y cómo los resolviste. Nos vemos en la próxima clase.
+

Curso de Claude Code/02-Módulo 2 Implementación Backend/02-Implementación de ratings en backend con Claude Code y Docker.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9ce88d89253978f5c82e5c669a5a96087e6f37f4e231c0ef991ec13d50cbadd8
+size 169721813

Curso de Claude Code/02-Módulo 2 Implementación Backend/02-Implementación de ratings en backend con Claude Code y Docker.vtt

@@ -0,0 +1,179 @@
+WEBVTT
+
+00:00:00.080 --> 00:00:08.700
+Ya tenemos configurado la base de datos junto con sus migraciones y los modelos para darle soporte al feature de ratings de Platiflix. El objetivo
+
+00:00:08.700 --> 00:00:17.040
+de este módulo es hacer la implementación de los planes que hicimos en las clases pasadas, es decir, crear el feature de ratings para todo
+
+00:00:17.040 --> 00:00:26.060
+el sistema de Platiflix. En esta clase vamos a crear la capa de servicios, los endpoints que le darán soporte al frontend para mostrar los
+
+00:00:26.060 --> 00:00:35.019
+ratings y también la creación de pruebas unitarias para garantizar que los cambios del backend no rompan la funcionalidad actual. Vamos al código. Con Cloud
+
+00:00:35.020 --> 00:00:47.140
+Code, versión dos, y Sonet 4.5, podemos ejecutar sesiones de más de treinta horas. Estas sesiones, eh, cuando se están ejecutando, nosotros constantemente tenemos que
+
+00:00:47.140 --> 00:00:58.340
+aprobar la ejecución de ciertos comandos. Hay una forma de poder evitar esa solicitud de permisos, que es pasándole el flag de Dangerously Skip Permissions
+
+00:00:58.340 --> 00:01:06.060
+a Claude. Cuando hacemos esto, se nos va a mostrar una pantalla en el que nos va a informar que Cloud Code va a ejecutar
+
+00:01:06.060 --> 00:01:17.680
+cualquier cosa que crea conveniente. Y esto solo debe ser ejecutado en entornos de máquinas virtuales o de contenedores con acceso restringido a Internet y
+
+00:01:17.680 --> 00:01:25.720
+que puedan ser restaurados si es dañado. Y ese es nuestro caso. Nuestro servicio está corriendo dentro de un contenedor de Docker que si se
+
+00:01:25.720 --> 00:01:34.260
+daña no pasa mucho porque tenemos comandos para poder de nuevo, eh, crear la base de datos, crear las semillas de la base de datos
+
+00:01:34.260 --> 00:01:43.420
+y ejecutar los tests. Entonces, esto es un caso conveniente para que nosotros podamos ejecutar a Cloud sin necesidad de que pida permisos. Le voy
+
+00:01:43.420 --> 00:01:53.020
+a decir que sí, que acepto. Y lo que vamos a hacer es decirle que implemente de la fase tres a la fase cinco del
+
+00:01:53.020 --> 00:02:05.220
+plan de implementación de ratings en backend. Lo voy a seleccionar, se lo paso como contexto y le voy a decir que implementa estas fases
+
+00:02:05.220 --> 00:02:15.140
+de forma secuencial. Esto es un prompt muy sencillo. ¿Por qué? Porque dentro del plan de implementación ya está la especificación de qué debe hacer
+
+00:02:15.140 --> 00:02:29.700
+con cada una de las fases. «Cuando termines de ejecutar cada fase, márcala como completada en el checklist». Vamos a habilitarle el modo de pensamiento
+
+00:02:29.700 --> 00:02:38.980
+y le damos enter para que empiece a ejecutar. Voy a detener la ejecución en este momento, porque algo importante que yo no le dije
+
+00:02:38.980 --> 00:02:47.600
+de contexto a Claude es que cuando vaya a ejecutar los tests tiene que hacerlo dentro del contenedor de Docker. Lo que vemos es que
+
+00:02:47.600 --> 00:02:58.480
+aquí está intentando ejecutar los tests como si estuviéramos dentro del entorno. Y no es así. Entonces le vamos a indicar que los tests y
+
+00:02:58.480 --> 00:03:21.060
+cualquier comando... del archivo make que necesites ejecutar debe ser utilizando a Docker. Es más, hagamos algo relevante. Podemos utilizar un comando que es el
+
+00:03:21.140 --> 00:03:30.210
+hash. Este hash lo que va a hacer es guardar en memoria la instrucción que yo le estoy dando. En este caso, la instrucción va
+
+00:03:30.210 --> 00:03:43.280
+a ser que cuando necesite ejecutar los tests de backend o cualquier migración, debe ejecutarlos dentro del contenedor de Docker. Cualquier comando que necesites ejecutar
+
+00:03:43.280 --> 00:04:01.880
+para el backend debe ser dentro del contenedor de docker api. Antes de ejecutarlo, certifica que esté funcionando el contenedor y revisa el archivo Makefile
+
+00:04:01.880 --> 00:04:14.170
+con los comandos que existen y úsalos. Entonces, aquí me va a preguntar qué es lo que quiero, que lo guarde en mi memoria como
+
+00:04:14.170 --> 00:04:20.060
+usuario o en la memoria del proyecto. Yo lo voy a guardar en la memoria del proyecto. Y ahora sí, le voy a indicar: los
+
+00:04:20.060 --> 00:04:35.700
+comandos de test debes ejecutarlos dentro de contenedor de Docker. Aquí vemos que Claude actualizó la fase tres de Service Layer cómo completabas cada uno
+
+00:04:35.700 --> 00:04:43.730
+de los ítems de esta lista. También terminó la fase cuatro, la de Endpoints, y también la fase cinco, en el que me dice que
+
+00:04:43.730 --> 00:04:54.320
+todos los tests pasan, treinta y nueve pasaron y uno le hizo skip. Vamos a leer el resumen de qué fue su ejecución . Me
+
+00:04:54.320 --> 00:05:05.680
+dice que ha completado exitosamente la implementación de las fases. En el Service Layer implementó esto, siete métodos que cumplen con lo que yo le
+
+00:05:05.680 --> 00:05:17.640
+pedí que implementara acá con esta documentación. Luego dice que creó los endpoints creando el directorio schemas y el archivo rating con modelos de Pydantic,
+
+00:05:17.640 --> 00:05:29.300
+siguiendo el patrón que ya tenía este repositorio y ya creó los endpoints y el testing. Esta ejecución fue muy larga. Y para certificar qué
+
+00:05:29.300 --> 00:05:39.440
+tanto contexto consumió, podemos utilizar el comando context. Y este context lo que me está diciendo es que casi nos consumimos toda la memoria y
+
+00:05:39.440 --> 00:05:50.260
+nosotros estamos utilizando a Sonet 4.5 de doscientos mil tokens de contexto. Es decir, sesenta y seis por ciento fue utilizado para la construcción de
+
+00:05:50.260 --> 00:06:01.980
+esta implementación del backend. Utilizó dos MCPs que eran todos relacionados con el editor de código y utilizó muy pocos los custom agents de Cloud
+
+00:06:01.980 --> 00:06:15.476
+Code. Como los tenemos ya dentro de este sistema.[continúa sonido de codificación] Ahora, como fue creado con el bypass de los permisos, nosotros necesitamos garantizar que el código
+
+00:06:15.476 --> 00:06:24.196
+que está acá es seguro. Para ello, Cloud Code ya tiene un comando predefinido que es de seguridad, que se llama security review, y lo
+
+00:06:24.196 --> 00:06:32.416
+que va a hacer es revisar los cambios que se han hecho en la rama actual con respecto a la seguridad. Entonces, le vamos a
+
+00:06:32.416 --> 00:06:45.596
+elegir y lo vamos a ejecutar. Lo que esperamos que analice este comando es la seguridad de todo el repositorio. Identifique vulnerabilidades y, dependiendo de
+
+00:06:45.596 --> 00:06:53.946
+eso, hacer los cambios respectivos en la base de código. Analizando el contexto, nos dimos cuenta que habíamos utilizado el sesenta y seis por ciento
+
+00:06:53.946 --> 00:07:02.316
+del contexto disponible. En este caso, cuando nos estamos quedando sin él, Cloud Code nos da un aviso. En este caso, de que tenemos nueve
+
+00:07:02.316 --> 00:07:09.156
+por ciento del contexto, eh, restante. Es decir, nos hemos consumido el noventa y un por ciento. Y aquí nos da la sugerencia de que
+
+00:07:09.156 --> 00:07:20.416
+podemos ejecutar el comando compact para compactar la conversación y continuar con la ejecución de nuestra sesión de código. El comando compact puede ser utilizado
+
+00:07:20.416 --> 00:07:29.456
+de dos formas: solo, en el que Cloud Code toma la decisión de cómo compactar la conversación, o dándole la indicación de qué es lo
+
+00:07:29.456 --> 00:07:41.536
+que se quiere que conserve en, eh, el contexto. Es decir, yo aquí le puedo decir que compacte la conversación y que conserva los hallazgos
+
+00:07:41.536 --> 00:07:53.036
+hechos en el análisis de seguridad. No lo voy a ejecutar ahora, pero a través de este comando podemos reutilizar el contexto de la misma
+
+00:07:53.036 --> 00:08:04.046
+conversación y llevárnoslo a una nueva de cierta manera. Si queremos iniciar una nueva conversación, tenemos el comando reset. Que con reset lo que vamos
+
+00:08:04.046 --> 00:08:11.556
+es a limpiar por completo la conversación y tener como si fuera una conversación nueva. Lo que yo voy a hacer en este momento es
+
+00:08:11.556 --> 00:08:23.736
+pedirle que documente los hallazgos en un nuevo archivo Markdown. Documenta estos hallazgos en un archivo, eh... y le vamos a indicar que sea en
+
+00:08:23.736 --> 00:08:37.096
+spec, con el formato que ya tienen el resto de archivos. Vamos a decirle que en este caso continúa con el cero tres. Por ejemplo,
+
+00:08:37.096 --> 00:08:44.116
+¿qué va a pasar? Él los hallazgos que ya encontró de seguridad de este repositorio los va a documentar en un archivo Markdown. Ese archivo
+
+00:08:44.116 --> 00:08:54.676
+Markdown luego puede ser utilizado para mejorar la base de código, tomando en consideración las vulnerabilidades que él encontró. Cloud Code ya guardó dentro de
+
+00:08:54.676 --> 00:09:05.796
+este archivo Markdown el análisis de seguridad que tuvo sobre el backend de este servicio. Vemos que tiene un resumen ejecutivo de cuáles fueron los
+
+00:09:05.796 --> 00:09:16.676
+hallazgos de, eh, vulnerabilidades que encontró, que es un reporte en el que se puede hacer bypass de la autorización en las operaciones de rating.
+
+00:09:16.676 --> 00:09:28.396
+Y aquí la cataloga, eh, según el estándar OWASP como un control de accesos roto con una confianza del noventa y cinco por ciento. De
+
+00:09:28.396 --> 00:09:39.936
+esta forma nosotros podemos ejecutar a Cloud Code de forma que no nos pida aceptar permisos para ejecutar cualquier comando, que él tenga total libertad
+
+00:09:39.936 --> 00:09:47.836
+y plena confianza en él de ejecutar lo que necesite y de crear el código que necesite, pero también nos ofrece la alternativa de luego
+
+00:09:47.836 --> 00:09:55.916
+revisar qué fue lo que creó. Ya tenemos la implementación de los features de backend terminada. Tenemos la migración de base de datos junto con
+
+00:09:55.916 --> 00:10:04.996
+las tablas, los modelos, el API y las pruebas creadas. También tenemos un análisis de seguridad sobre lo que acabamos de crear. Utiliza a Cloud
+
+00:10:04.996 --> 00:10:13.896
+Code y este nuevo análisis de seguridad para corregir esta vulnerabilidad. Déjame en la sección de comentarios cómo resolviste este problema. Nos vemos en la
+
+00:10:13.896 --> 00:10:14.896
+próxima clase.
+

Curso de Claude Code/02-Módulo 2 Implementación Backend/03-Implementación de ratings con estrellas en lista de cursos frontend.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e1fa1cf9b140a522a0f936d3349e01ab7bf012950e52ccbcd5f10d785f4ba43
+size 252363972

Curso de Claude Code/02-Módulo 2 Implementación Backend/03-Implementación de ratings con estrellas en lista de cursos frontend.vtt

@@ -0,0 +1,296 @@
+WEBVTT
+
+00:00:00.200 --> 00:00:06.880
+Vamos a implementar el sistema ratings en el frontend. Hemos venido preparando el proyecto para que el backend tenga el API y la base de
+
+00:00:06.880 --> 00:00:16.079
+datos lista para guardar las estrellas de cada curso. Antes de avanzar, te invito a que intentes revisar y solucionar los problemas del frontend antes
+
+00:00:16.079 --> 00:00:23.380
+de esta clase. En el repositorio que está en la sección de enlaces, esté ya todo solucionado. Pero utiliza Cloud Code para identificar qué puede
+
+00:00:23.380 --> 00:00:31.640
+estar fallando y solucionarlo. En las clases anteriores, hemos venido preparando los planes de implementación de ratings tanto en backend como en frontend. En la
+
+00:00:31.640 --> 00:00:41.420
+sección de frontend, tenemos seis fases de implementación que empezaremos en esta clase. Lo primero que tenemos que hacer para poder empezar la implementación es
+
+00:00:41.420 --> 00:00:50.600
+correr el servidor. En la carpeta de frontend, tenemos el archivo README.md y usualmente es allí en donde se encuentran las instrucciones para poner a
+
+00:00:50.600 --> 00:00:58.900
+correr el servicio. Cuando no está explícito, se puede utilizar al mismo Cloud para que entienda la base de código y vea una forma de
+
+00:00:58.900 --> 00:01:06.720
+ponerlo a correr. Como esto ya está construido, lo vamos a aprovechar. Entonces, vamos a la terminal y vamos a entrar a la carpeta de
+
+00:01:06.720 --> 00:01:15.759
+frontend. En la carpeta de frontend abriremos la sesión de conversación con Cloud y vemos que el comando para correr este servicio es con yarn
+
+00:01:15.760 --> 00:01:25.800
+dev. Antes de hacer el yarn dev, necesitamos garantizar que las dependencias están instaladas. Entonces, podemos hacer fácilmente un yarn install. Esto es usualmente el
+
+00:01:25.800 --> 00:01:34.120
+paso a seguir cuando se trabaja en el frontend. Se instalan dependencias y luego se pone a correr el proyecto. Entonces, ahora sí abrimos Cloud
+
+00:01:34.120 --> 00:01:44.240
+y utilizando el comando de Bash, vamos a escribir yarn dev. De esta manera, nosotros vamos a prender el servidor y Cloud Code va a
+
+00:01:44.240 --> 00:01:51.560
+tener el contexto de lo que está pasando con este servidor, porque cualquier salida que tenga este comando, Cloud Code lo va a tomar como
+
+00:01:51.560 --> 00:02:01.940
+contexto. Entonces, ejecutamos este comando y vamos a ver que se nos habilita la opción de correr esto en background. ¿Por qué? Porque cuando se
+
+00:02:01.940 --> 00:02:09.800
+ejecuta este comando, el servicio siempre está corriendo. Es decir, siempre va a haber una salida y siempre va a estar esperando que algo suceda.
+
+00:02:09.800 --> 00:02:17.940
+Si lo mandamos al background, utilizando control B, vamos a ver que abajo se nos va a habilitar una nueva opción, que es que este
+
+00:02:17.940 --> 00:02:28.260
+comando está corriendo y estuvo listo en seiscientos treinta y nueve milisegundos. Si queremos ver la salida de este comando, podemos utilizar Bashes. Y en
+
+00:02:28.260 --> 00:02:35.680
+Bashes se nos va a mostrar cuáles son las tareas que están en background. Y en este caso solamente tenemos una, que es el servicio
+
+00:02:35.680 --> 00:02:43.380
+de frontend. Y aquí vemos que tiene una salida. El servicio de frontend, en este caso, está corriendo en localhost tres mil. Entonces, vamos a
+
+00:02:43.380 --> 00:02:52.020
+ir al navegador y abrimos esta dirección. En el navegador vemos que se nos muestra un error. Y este error es usualmente porque no puede
+
+00:02:52.020 --> 00:03:01.500
+encontrar la lista de cursos. Esto significa que el servicio de backend no está prendido. Volvamos al editor de texto y pongamos a funcionar el
+
+00:03:01.500 --> 00:03:12.060
+servicio de backend. Como aprendimos en la clase anterior, el servicio de backend tiene aquí una opción para poner a correrlo muy fácilmente, que es
+
+00:03:12.060 --> 00:03:20.480
+con el archivo Makefile. Y aquí lo podemos prender. Entonces, vamos a entrar a backend y vamos a ejecutar make start. Y aquí con make
+
+00:03:20.480 --> 00:03:28.660
+start ya vamos a tener los dos servicios importantes del backend, que es la base de datos y el API. Aquí seguimos viendo que, eh...
+
+00:03:28.660 --> 00:03:38.260
+sigue corriendo la tarea de el servidor de desarrollo del frontend. Y podemos ir al navegador nuevamente y recargar. Aquí ya tenemos a PlatziFlix en
+
+00:03:38.260 --> 00:03:47.720
+la sección de frontend corriendo. Con el frontend corriendo, ya podemos empezar la implementación del feature de ratings. Vamos a utilizar el plan de especificación
+
+00:03:47.720 --> 00:03:54.860
+que hemos construido a lo largo del curso para que Cloud Code entienda qué debe hacer y lo empiece a ejecutar. Para salirnos de esta
+
+00:03:54.860 --> 00:04:04.200
+pantalla, eh, simplemente presionamos la tecla enter, espacio o escape. Con esto ya nos salimos de la interfaz de bashes y volvemos a la conversación
+
+00:04:04.200 --> 00:04:13.040
+con Cloud Code. Aquí podemos ver o darle el contexto de que este va a ser el plan de implementación. Entonces, podemos utilizar dos partes:
+
+00:04:13.040 --> 00:04:24.380
+darlo como contexto utilizando, eh, command option K, y aquí lo ponemos como contexto, o ya como estaba conectado al nave-- al editor de texto,
+
+00:04:24.380 --> 00:04:32.680
+lo podemos utilizar. ¿Qué va a ser la instrucción para que empiece a aplicar este plan de implementación? Primero, que entienda muy bien cuál es
+
+00:04:32.680 --> 00:04:41.440
+el contexto de este plan. ¿Por qué? Porque sin el contexto necesario va a poder crear cualquier cosa. Luego de que entienda cuál es el
+
+00:04:41.440 --> 00:04:50.940
+plan, le pediremos al subagente de frontend, que ya tenemos construido, que empiece con la implementación. Entonces, vamos por pasos. Primero, dar contexto y luego
+
+00:04:50.940 --> 00:04:59.920
+sí la implementación. Aquí está el resumen de lo que Cloud analizó y entendió del plan de implementación que tenemos de ratings. Dice que permite
+
+00:04:59.920 --> 00:05:10.520
+a los usuarios calificar cursos con estrellas de uno cinco y visualizar estadísticas agregadas. Incluye backend y frontend. Excelente. Ya entendió el propósito del feature
+
+00:05:10.520 --> 00:05:18.659
+de ratings y entendió muy bien qué es lo que debe hacer. Ahora, vamos a invocar al agente de frontend para que haga la implementación
+
+00:05:18.660 --> 00:05:28.140
+de los componentes de rating. En este caso, únicamente para la lista de cursos. ¿Por qué? Porque te voy a invitar a que tú termines
+
+00:05:28.140 --> 00:05:36.560
+la implementación de ratings tanto para la vista de curso individual como la vista de clases. Al inicio de esta sesión de conversación del frontend
+
+00:05:36.560 --> 00:05:45.050
+con Cloud Code, nosotros entramos a la carpeta frontend. En la carpeta frontend no están disponibles los subagentes que hemos construido a lo largo de
+
+00:05:45.050 --> 00:05:53.760
+este curso. Entonces, para aprovechar la conversación que ya tenemos, vamos a utilizar un feature de Cloud Code que permite exportar la conversación y utilizarla
+
+00:05:53.760 --> 00:06:03.280
+en otra sesión. Vamos al editor. Cloud Code tiene el comando export, que permite exportar la conversación actual a un archivo o al portapapeles de
+
+00:06:03.280 --> 00:06:11.736
+la computadora. Cuando lo seleccionamos, él nos va a mostrar esas dos opciones.Copiarlo al portapapeles o guardarlo en un archivo. Yo voy a elegir la
+
+00:06:11.736 --> 00:06:22.456
+opción uno. Y ahora, en mi portapapeles, ya tengo disponible esta conversación. Nos salimos y vamos a la carpeta padre de frontend, que en este
+
+00:06:22.456 --> 00:06:33.076
+caso es el curso de Cloud Code. Abrimos una nueva sesión de Cloud y le vamos a dar una pequeña instrucción: [tecleo]esta es una conversación
+
+00:06:33.076 --> 00:06:51.856
+que tenía en otra sesión contigo. Utilízala y entiende el contexto que estábamos teniendo en esa conversación. Y pego. Cuando se pega algo en Cloud
+
+00:06:51.856 --> 00:06:58.936
+Code y es muy extenso, él lo va a comprimir y va a decir un mensaje de que se, eh, pegó un texto de más
+
+00:06:58.936 --> 00:07:06.816
+de cien líneas. Así, en, de esta forma, nosotros tenemos una conversación un poco más ordenada y no un montón de texto. Pero cuando se
+
+00:07:06.816 --> 00:07:15.736
+envía la conversación, sí está disponible todo el texto que le pegamos en este caso. Cuando él lea esta conversación, lo que va a hacer
+
+00:07:15.736 --> 00:07:24.515
+es entenderlo, porque así fue la instrucción que yo le di. Y como ya tiene todo el contexto necesario, ya podemos utilizar al subagente de
+
+00:07:24.515 --> 00:07:36.076
+Agent, del frontend, que lo tenemos construido en las clases anteriores como especialista en desarrollo frontend. Como podemos ver, y yo como abrí otra sesión,
+
+00:07:36.076 --> 00:07:45.236
+es posible que el servidor de desarrollo del frontend se haya apagado. Vamos a volver a correrlo utilizando el bash mode de Cloud Code y
+
+00:07:45.236 --> 00:07:55.576
+le damos la instrucción de yarn dev. Aquí lo que me dice es que no se puede correr el servidor de frontend desde esta carpeta.
+
+00:07:55.576 --> 00:08:05.716
+Entonces, lo podemos crear por fuera, es decir, podemos correr el servidor por fuera haciendo un yarn dev y ya va a estar disponible. En
+
+00:08:05.716 --> 00:08:14.876
+este caso, no va a tener el contexto, pero igualmente se podría utilizar el, el servidor de frontend. Y aquí le vamos a decir: [tecleo]
+
+00:08:14.876 --> 00:08:34.116
+utiliza al subagente de frontend para empezar la implementación de los componentes de rating solamente para la vista, para la lista de cursos. Aquí me
+
+00:08:34.116 --> 00:08:43.076
+está pidiendo que apruebe la edición sobre el archivo rating punto Typescript. Y aquí lo que está haciendo es la implementación de las interfaces según
+
+00:08:43.076 --> 00:08:52.616
+el plan que nosotros le dimos acá, cuya fase uno es la implementación de tipos e interfaces de ratings. Entonces, vamos a probarlo y dejamos
+
+00:08:52.616 --> 00:09:01.556
+que continúe con la implementación del feature. Como ya está haciendo varias modificaciones, yo voy a cambiar para que permita cualquier edición durante esta sesión
+
+00:09:01.556 --> 00:09:12.716
+de conversación. Entonces, presionamos la opción dos. Aquí pasó algo curioso, que Claude y cualquier agente de codificación tiende a hacer, y es que se
+
+00:09:12.716 --> 00:09:22.036
+va mucho más allá de lo que le solicitamos. Nosotros en las instrucciones iniciales, aunque no fuimos tan explícitos, le pedimos que hiciera la implementación
+
+00:09:22.036 --> 00:09:30.675
+de la UI del componente de ratings en la lista de cursos. Pero ahorita lo que está haciendo es revisando incluso lo que está definido
+
+00:09:30.675 --> 00:09:39.336
+en el backend. Entonces, paramos la ejecución y vamos a decirle que se estaba yendo mucho más allá. Que lo que necesitamos es que se
+
+00:09:39.336 --> 00:09:47.956
+cree el componente de ratings y que aunque el API aún no esté implementada, pueda mostrar un mock de los valores del rating para ciertos
+
+00:09:47.956 --> 00:09:56.076
+cursos. Entonces, con otro prompt le vamos a indicar que estaba equivocado y que corrija haciendo lo que le vamos a indicar. Entendió mi instrucción
+
+00:09:56.076 --> 00:10:02.956
+y aquí me está diciendo que va a implementar directamente los componentes de UI. Y ante eso, me muestra cuáles son los to dos que
+
+00:10:02.956 --> 00:10:11.156
+él volvió a pensar y volvió a implementar para este caso. Me dice que ya todo está implementado y que ahora quiere iniciar el servidor.
+
+00:10:11.156 --> 00:10:17.076
+Aquí lo que va a pasar es que como nosotros corrimos el servidor ya en otra terminal, va a decir que no va a poder
+
+00:10:17.076 --> 00:10:24.356
+correrlo. Entonces, claro, el puerto tres mil ya está en uso. Entonces, lo que podemos hacer es parar este servicio acá, lo detuvimos y le
+
+00:10:24.356 --> 00:10:34.716
+pedimos a Cloud Code en este caso que vuelva a ejecutar el yarn dev para levantar el servicio. Veamos qué hace. Excelente. Aquí ya corrió
+
+00:10:34.716 --> 00:10:44.336
+el servicio de frontend, pero en esta sesión de conversación. Muy bien. Si escribimos bashes, vamos a ver que tenemos dos, eh, instancias corriendo, una
+
+00:10:44.336 --> 00:10:51.596
+que ya no está funcionando y otra que está lista y es el yarn dev. Muy bien. Entonces, vamos al navegador y veamos qué tal
+
+00:10:51.596 --> 00:10:59.266
+quedó el componente de ratings en la lista de cursos. Aquí vemos que agregó las estrellas la cantidad e hizo un pequeño efecto con CSS
+
+00:10:59.266 --> 00:11:08.056
+sobre el rating promedio de este curso. Y así para el resto de cursos. Recordemos que le dimos o le dijimos a Claude que utilizara
+
+00:11:08.056 --> 00:11:16.816
+datos mocked, que no existiera la implementación o la integración con el API que hemos hecho a lo largo del curso, sino que, eh, utilizara
+
+00:11:16.816 --> 00:11:26.675
+datos mocked para poder ver cómo estaba quedando el componente. Muy bien. Aquí nos podemos dar cuenta de que existen aún múltiples mejoras en CSS
+
+00:11:26.675 --> 00:11:36.496
+y lo que vamos a hacer es capturar pantalla y darle contexto a Cloud Code utilizando la imagen que acabamos de capturar. Si capturamos pantalla,
+
+00:11:36.496 --> 00:11:46.656
+podemos capturar solo una sección o capturar la pantalla completa. Cuando capturamos pantalla, en este caso en MacOS, se queda la imagen dentro del portapapeles
+
+00:11:46.656 --> 00:11:57.716
+del, eh, del computador. Eso lo podemos pegar en Cloud Code, pero no utilizando la tecla command, sino la tecla control. Entonces, volvamos al editor
+
+00:11:57.716 --> 00:12:06.435
+y peguemos la imagen. Nos salimos de acá y pegamos la imagen presionando control B. Aquí lo que pasa es que Cloud Code, al igual
+
+00:12:06.435 --> 00:12:12.796
+que cuando copiamos o pegamos un texto muy grande, lo que hace es achicar el contexto. En este caso, no nos muestra la imagen que
+
+00:12:12.796 --> 00:12:18.616
+acabamos de pegar, pero sí nos dice que hay una imagen que está pegada. Lo que le vamos a pedir, entonces, es que haga un
+
+00:12:18.616 --> 00:12:26.848
+análisis de esta imagen para ver qué tanto entiende de lo que le acabé de decir. [tecleo]Haz un análisis a--Un análisis detallado de la imagen
+
+00:12:26.848 --> 00:12:36.408
+que te acabo de compartir. Aquí voy a aprender el modo de pensamiento extendido para que pueda hacer el análisis detallado como le estoy pidiendo.
+
+00:12:36.408 --> 00:12:49.808
+También, si quisiéramos, le podemos decir ultrathink sobre la imagen que te acabé de pasar, porque es el componente que acabas de crear. Lo mandamos
+
+00:12:49.808 --> 00:12:57.708
+y vemos que nos va a responder. En este caso, cuando capturé pantalla, me capturó pantalla de un sitio que no era el que yo
+
+00:12:57.708 --> 00:13:08.148
+esperaba capturar, sino de, en este caso, de otro monitor que yo tengo en este momento. Entonces, volvamos al navegador y capturemos la pantalla que
+
+00:13:08.148 --> 00:13:19.448
+tenemos, pero como si fuera un segmento, no la pantalla completa. Y lo pegamos con control be. Y le decimos: «Esta sí es la imagen».
+
+00:13:19.448 --> 00:13:27.168
+Haz el análisis. Aquí podemos ver el análisis que hizo sobre la imagen que le acabo de pegar. Aquí me dice que ahora sí ve
+
+00:13:27.168 --> 00:13:33.988
+el componente de star-rating porque antes le había pasado otra imagen incorrecta. Y aquí empieza a analizar lo que ve. Lo primero que ve es
+
+00:13:33.988 --> 00:13:41.408
+el curso de React como primera card con la cantidad de estrellas, que en este caso es tres punto cinco. Luego empieza a hacer un
+
+00:13:41.408 --> 00:13:51.268
+análisis más detallado sobre los estilos que acaban de implementar, el contador que acaba de hacer, el modo read-only y los datos moqueados que él
+
+00:13:51.268 --> 00:14:01.308
+hizo para representar este componente. Entonces, de esta forma nosotros podemos darle contexto a Cloud Code, no únicamente del código que tenemos, sino también de
+
+00:14:01.308 --> 00:14:10.648
+las imágenes que podemos capturar de nuestro entorno. Puede ser no únicamente una captura de pantalla, sino también una imagen de referencia. Guíate de esta
+
+00:14:10.648 --> 00:14:19.948
+interfaz para que lo implementes de esta manera. Revisa que los estilos que están dentro de esta captura de pantalla correspondan a este otro que
+
+00:14:19.948 --> 00:14:28.248
+te paso como referencia. Entonces, ahí se puede jugar con una gran cantidad de contexto, no únicamente contexto, sino también con imágenes. Ya tenemos el
+
+00:14:28.248 --> 00:14:37.008
+componente de ratings integrado en la lista de cursos. Recuerda hacer el componente, pero en este caso para el detalle del curso y dejarme en
+
+00:14:37.008 --> 00:14:43.928
+la sección de comentarios qué retos tuviste y cómo los resolviste. En la próxima clase, en vez de utilizar datos mock, vamos a conectar estos
+
+00:14:43.928 --> 00:14:48.448
+componentes con la API que construimos en las clases de backend. Nos vemos allá.
+

Curso de Claude Code/02-Módulo 2 Implementación Backend/04-Integración de ratings con API usando Claude Code.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:955ddb2d058a239a1386d54a53a3eeb98b5c701d3133a0aee7a59b7bb2defa6d
+size 109622975

Curso de Claude Code/02-Módulo 2 Implementación Backend/04-Integración de ratings con API usando Claude Code.vtt

@@ -0,0 +1,131 @@
+WEBVTT
+
+00:00:00.120 --> 00:00:07.960
+Ya tenemos el esquema de base de datos funcional para que guarde los ratings por curso. Hemos construido los endpoints de la API para que
+
+00:00:07.960 --> 00:00:15.979
+utilice lo que está en la base de datos y nos permita guardar y leer. También, construimos el componente que muestra el rating por curso,
+
+00:00:15.980 --> 00:00:24.380
+pero en la lista de cursos. En esta clase, vamos a terminar la implementación de ratings, aprovechando todo lo que hemos construido para que el
+
+00:00:24.380 --> 00:00:33.200
+frontend lea del API y muestre la información correcta en la pantalla del navegador. Vamos a utilizar un feature de Cloud Code que permite agregar
+
+00:00:33.200 --> 00:00:43.020
+como contexto un nuevo directorio de trabajo. En este caso, servirá de ejemplo, porque nosotros tenemos dentro de una misma carpeta ambos proyectos, tanto el
+
+00:00:43.020 --> 00:00:51.180
+backend como el frontend. Pero como nosotros entramos a la carpeta de frontend, no tiene contexto directo de esta carpeta de backend. Y esto va
+
+00:00:51.180 --> 00:00:58.800
+a servir, por ejemplo, si es una carpeta externa que queremos agregar como contexto. Si tenemos dos proyectos que no están contenidos en la misma
+
+00:00:58.800 --> 00:01:07.640
+carpeta, de esta forma es que vamos a darle contexto a cierta conversación sobre un directorio externo. Entonces, abrimos la terminal y lo que vamos
+
+00:01:07.640 --> 00:01:16.440
+a hacer es buscar cuál es la dirección absoluta del directorio que queremos agregar como contexto. En este caso, entramos a backend y, ejecutando el
+
+00:01:16.440 --> 00:01:26.680
+comando pwd, vamos a obtener esta dirección absoluta. La copiamos, vamos a Cloud Code y utilizamos el comando adddir. Con este adddir le vamos a
+
+00:01:26.680 --> 00:01:36.060
+pegar lo que acabamos de copiar de dirección absoluta. Y aquí nos va a decir que ya está accesible como contexto dentro de la conversación.
+
+00:01:36.060 --> 00:01:45.580
+Como necesitamos hacer que el frontend entienda el backend para hacer la implementación del API, vamos a pedirle que, con un prompt, haga esa, eh,
+
+00:01:45.580 --> 00:02:02.320
+investigación en el repositorio de backend. «Averigua todo lo que necesites para hacer la integración del API de ratings en el frontend. Busca los archivos
+
+00:02:02.320 --> 00:02:19.220
+dentro de la carpeta... carpeta backend que tengan relevancia para tu integración». Ya hizo la investigación dentro del backend y se dio cuenta de todo
+
+00:02:19.220 --> 00:02:26.980
+lo que hemos construido. Y me hace un resumen bastante bueno de qué es lo que encontró. En este caso, me muestra el modelo de
+
+00:02:26.980 --> 00:02:37.220
+datos de ratings. Me muestra cuáles son los endpoints que están disponibles para, eh, los ratings. También me muestra cuál es el esquema de respuesta.
+
+00:02:37.220 --> 00:02:46.120
+Es decir, ya tiene un contexto completo a partir del código que leyó e interpretó. Muchas veces esto no es posible de hacer. ¿Por qué?
+
+00:02:46.120 --> 00:02:54.540
+Porque si trabajamos con una API externa y no tenemos acceso al código fuente, no es posible acceder o hacer lo que acabamos de incluir
+
+00:02:54.540 --> 00:03:03.980
+en la conversación, que es que vaya y analice el código que está descrito. Entonces, otra herramienta que tenemos es pedirle que haga llamados al
+
+00:03:03.980 --> 00:03:15.000
+API para que entienda la estructura. Pero al final esto es muy ineficiente. Nosotros sabemos que en el API tenemos la documentación de esta utilizando
+
+00:03:15.000 --> 00:03:23.940
+algo que se llama swagger. Entonces, vamos al navegador y extraigamos el swagger de este API. Esta es la dirección del API, que es localhost
+
+00:03:23.940 --> 00:03:30.760
+en el puerto ocho mil. Pero si yo voy a docs, aquí vamos a ver que se abre el swagger de PlatziFlix. Y aquí abajo
+
+00:03:30.760 --> 00:03:40.540
+hay un link, que es el openapi.json. Este open api lo que tiene es la definición de todos los endpoints que tenemos en esta API.
+
+00:03:40.540 --> 00:03:54.160
+Como es texto, se puede copiar y dárselo como contexto a Cloud Code. Entonces, lo podemos copiar o incluso, mucho mejor, es decirle: «haz un
+
+00:03:54.160 --> 00:04:08.670
+curl a esta dirección y extrae todo el contexto que puedas del openapi.json». Y le pasamos la dirección. ¿Qué es lo que espero que haga?
+
+00:04:08.670 --> 00:04:18.079
+Que haga el llamado, extraiga el json y lo utilice como contexto. Ya terminó de extraer la información del openapi.json y aquí me está haciendo
+
+00:04:18.079 --> 00:04:26.540
+un resu-resumen de qué fue lo que encontró. Y me hace algunas especificaciones sobre el rating. Como ya tiene contexto tanto del código como del
+
+00:04:26.540 --> 00:04:37.700
+API, le voy a pedir que haga la implementación del API en el componente que acaba de crear. «Utilizando el contexto, haz la integración del
+
+00:04:37.700 --> 00:04:46.460
+API para que traiga el rating del curso». Y aquí le vamos a hacer muy explícito que es en la lista de cursos. «En la
+
+00:04:46.460 --> 00:05:00.719
+página de lista de cursos para mostrar el valor que viene desde el app, ya que usamos un mock». Esto es bastante interesante, porque Cloud
+
+00:05:00.720 --> 00:05:11.300
+Code se dio cuenta que en la lista de cursos, en el endpoint que trae la lista de cursos, no está incluido el rating. Es
+
+00:05:11.300 --> 00:05:20.000
+decir, que para terminar la integración del frontend con el backend, hay que hacer algo en el backend. Interrumpí esta ejecución para mostrar que cuando
+
+00:05:20.000 --> 00:05:30.320
+hacemos esta integración de varios directorios, somos capaces de hacer modificaciones en ambas partes. Entonces, como ya terminó de hacer esta investigación y tiene el
+
+00:05:30.320 --> 00:05:42.020
+plan de ejecución, le voy a decir que lo haga. «Ejecuta la lista de todos». Cloud ya me avisa que terminó la integración del API
+
+00:05:42.020 --> 00:05:49.640
+con el frontend. Esto quiere decir que en el navegador ya tenemos los datos reales que retorna el API. En este caso, para el curso
+
+00:05:49.640 --> 00:05:57.500
+de React, dice que el total ratings es de cuatro, con un promedio de cuatro punto veinticinco. Si vamos al navegador y actualizamos, vamos a
+
+00:05:57.500 --> 00:06:05.859
+ver esos datos. Vemos que el curso de React sí tiene efectivamente el rating que está diciendo: cuatro punto cinco con una cantidad de cuatro
+
+00:06:05.860 --> 00:06:15.040
+y el curso de Python con una cantidad de dos. De esta forma concluimos la integración del backend con el frontend. Hacemos correcciones en ambas
+
+00:06:15.040 --> 00:06:23.820
+direcciones. Cuando estamos integrando el frontend, corregimos qué falta en el backend y también podemos hacer que cuando hacemos correcciones en el backend, podemos hacer
+
+00:06:23.820 --> 00:06:33.420
+modificaciones en el frontend. Esto es poderoso porque Cloud Code permite, entonces, tener un flujo completo end to end, full stack, de cierta manera, de
+
+00:06:33.420 --> 00:06:41.840
+desarrollo de código. Ahora, el reto que tienes es terminar la implementación de ratings, en el que un estudiante pueda guardar qué tal le apareció
+
+00:06:41.840 --> 00:06:48.680
+el curso y mostrar en el detalle del curso cuál es el rating para él. Déjame en la sección de comentarios qué features de Cloud
+
+00:06:48.680 --> 00:06:50.800
+Code utilizaste y qué retos tuviste.
+

Curso de Claude Code/03-Módulo 3 Gestión de Contexto y Comandos/01-Instalación de servidores MCP en Claude Code.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df7c6c0aee0f31fda911313b6b1d47c6a18f5a9efb9b1aadd75ab6039cb810ee
+size 223878507

Curso de Claude Code/03-Módulo 3 Gestión de Contexto y Comandos/01-Instalación de servidores MCP en Claude Code.vtt

@@ -0,0 +1,272 @@
+WEBVTT
+
+00:00:00.120 --> 00:00:09.620
+Lo más importante cuando trabajamos con un agente de codificación es contexto. El equipo de Anthropic desarrolló el MCP, que es el protocolo de contexto
+
+00:00:09.620 --> 00:00:20.370
+para modelos. Esto, en palabras simples, es la forma estándar que tenemos de proveerle a un modelo de contexto y de capacidades extendidas más allá
+
+00:00:20.370 --> 00:00:28.900
+para lo que fue fabricado. Cloud Code permite agregar servidores MCPs fácilmente y poder utilizarlos. En esta clase vamos a hacer la instalación de tres
+
+00:00:28.900 --> 00:00:37.980
+servidores MCPs que a mí me parecen muy relevantes para tener un flujo de trabajo completo como desarrollador. Vamos al código. Cloud Code permite hacer
+
+00:00:37.980 --> 00:00:47.040
+la gestión de servidores MCP a través de la línea de comandos. Si hacemos: «cloud mcp help», aquí nos va a mostrar la ayuda que
+
+00:00:47.040 --> 00:00:58.960
+necesitamos para poder hacer la gestión de los servidores MCPs. Podemos ver que tenemos cómo agregarlos y cómo servir servidores MCPs. También listar cuáles tenemos,
+
+00:00:58.960 --> 00:01:10.980
+remover los que tenemos instalados y así sucesivamente. Hay dos formas de poder agregar servidores MCPs a Cloud Code. Uno es importarlos desde la aplicación
+
+00:01:10.980 --> 00:01:19.679
+de escritorio de Cloud. Cloud no es únicamente un agente de codificación, sino también es una interfaz en la que podemos tener un chat con
+
+00:01:19.680 --> 00:01:30.840
+el modelo que querramos. Entonces, allá también se pueden hacer implementación o instalación de servidores MCPs. Si lo tenemos configurado, podemos ejecutar este comando y
+
+00:01:30.840 --> 00:01:41.880
+los traerá de donde están. También podemos hacer la instalación de servidores MCPs a través del comando app. Si nosotros le pedimos la ayuda, aquí
+
+00:01:41.880 --> 00:01:50.460
+vamos a ver cuáles son las formas que tenemos de agregar los servidores MCPs. Hay tres tipos de servidores MCPs: a través de HTTP, de
+
+00:01:50.460 --> 00:01:58.700
+Server Side Event o del estándar Input/Output. Si quieres conocer más sobre MCPs, te invito a que tomes el curso que tenemos acá en Platzi,
+
+00:01:58.700 --> 00:02:05.920
+que dejé el link en la sección de enlaces y de recursos. Como dije al inicio, vamos a hacer la implementación de tres servidores MCPs
+
+00:02:05.920 --> 00:02:14.520
+que a mí me parecen lo suficientemente sencillos de implementar y útiles para tener un flujo de trabajo profesional como desarrollador. El primero es el
+
+00:02:14.520 --> 00:02:24.260
+de Playwright. Entonces, vamos al navegador y veamos la documentación. El servidor MCP de Playwright lo que permite es abrir un navegador y permitirle a
+
+00:02:24.260 --> 00:02:33.940
+los modelos de lenguaje la navegación en ciertos sitios webs. Entonces, si quieres más información, puedes leer la descripción, pero en este caso nos basta
+
+00:02:33.940 --> 00:02:45.060
+con bajar y buscar la sección de Cloud Code. Y aquí está el comando para poder instalarlo. Lo podemos copiar y regresamos a la terminal.
+
+00:02:45.060 --> 00:02:54.920
+En la terminal, pegamos el comando, presionamos enter. Aquí me dice que ya fue instalado, es decir, fue agregado. ¿Cómo lo certificamos? Si hacemos: cloud
+
+00:02:54.920 --> 00:03:03.620
+mcp list. Y aquí vamos a ver que está haciendo un checking de cuáles son los estatus de los servicios MCP que están instalados. En
+
+00:03:03.620 --> 00:03:12.600
+este caso, el de Playwright ya está conectado. Entonces, abrimos a Cloud y gestionamos los MCPs a través del comando MCP. Aquí me da la
+
+00:03:12.600 --> 00:03:20.600
+lista de cuáles son los servidores que están disponibles. Y Playwright ya está listo y está conectado. Entonces, ¿cómo se utiliza el ser-- el servidor
+
+00:03:20.600 --> 00:03:30.120
+de Playwright? Como permite automatizar y darle la capacidad al modelo de navegar sitios webs, lo que le vamos a pedir es que navegue al
+
+00:03:30.120 --> 00:03:41.500
+local host en la lista de cursos que hemos venido trabajando. ¿Cómo lo hacemos? Vamos al navegador y copiamos la ruta que hemos estado modificando.
+
+00:03:42.320 --> 00:03:52.720
+Copiamos la ruta y nos devolvemos a Cloud. Y lo podemos hacer explícitamente, es decir, decirle a Cloud Code que utilizando el MCP de Playwright
+
+00:03:52.720 --> 00:04:01.600
+visite este sitio web. Para verlo en ejemplo y ver cómo funciona, vamos a separar la pantalla y tenemos las dos partes en paralelo, tanto
+
+00:04:01.600 --> 00:04:10.980
+el editor como el navegador. Utilizando el MCP de Playwright, visita este sitio. ¿Qué va a hacer él? Va a abrir el navegador. Aquí me
+
+00:04:10.980 --> 00:04:21.220
+pide permiso. ¿Por qué? Porque un servidor MCP se compone de tres cosas importantes: de tools, de resources y de prompts. En este caso, me
+
+00:04:21.220 --> 00:04:28.219
+está pidiendo a mí permiso para poder utilizar la tool de navegar a una URL. Yo le voy a decir que sí y que lo
+
+00:04:28.220 --> 00:04:37.660
+voy a permitir durante esta sesión. Entonces, aquí se me abre el navegador, lo voy a poner acá, ¿y qué está haciendo acá? Aquí lo
+
+00:04:37.660 --> 00:04:45.980
+que está haciendo Cloud es utilizar el contexto que está tomando de Playwright y la navegación que le está haciendo. Esta ventana del navegador la
+
+00:04:45.980 --> 00:04:54.560
+está gestionando automáticamente el MCP de Playwright. Yo no estoy haciendo nada. Veamos qué tantas capacidades tiene y cómo podemos hacer esto. Una de las
+
+00:04:54.560 --> 00:05:03.080
+cosas importantes para los que sirve Playwright es para hacer unos tests de funcionalidad. Aquí me está diciendo que no se están cargando las imágenes
+
+00:05:03.080 --> 00:05:12.140
+y puede incluso tomar contexto de los errores de la consola del navegador. Muy bien. Entonces, como una demostración, le voy a pedir que haga
+
+00:05:12.140 --> 00:05:26.960
+scroll. «Haz scroll del sitio que estás visitando y utiliza las imágenes que puedes capturar para describir qué estás viendo». Las herramientas que tiene Playwright
+
+00:05:26.960 --> 00:05:33.960
+son muy amplias. Una de ellas es hacer scroll del sitio, es decir, que pueda bajar. Otra cosa que puede hacer es tomar fotos y
+
+00:05:33.960 --> 00:05:44.520
+utilizarlas como contexto. También grabar videos. En clases anteriores vimos cómo capturar pantalla y pasarlas como referencia. Playwright permite hacer la automatización de ese flujo,
+
+00:05:44.520 --> 00:05:52.530
+revisar qué se está renderizando, pasárselo al modelo y que el mismo tome las decisiones sobre qué mejorar. Aquí me está pidiendo permiso para que
+
+00:05:52.530 --> 00:05:59.320
+tome un screenshot. También le voy a decir que sí para toda la sesión. ¿Qué sucedió acá? Hizo scroll y luego esperó dos segundos para
+
+00:05:59.320 --> 00:06:07.940
+revisar si el scroll efectivamente se había hecho.Yo no estoy coordinando en este momento al navegador, sino que el mismo MCP es quien está haciendo
+
+00:06:07.940 --> 00:06:15.960
+las gestiones a la ventana que está abierta. Aquí ya me está describiendo qué fue lo que pudo ver. Dice que la estructura accesabilidad que
+
+00:06:15.960 --> 00:06:21.800
+está capturando puede escribir lo que ve en este sitio web, que es el que nosotros le pedimos que hiciera. Ve el branding de Platzi
+
+00:06:21.800 --> 00:06:29.160
+Flix y de cursos. Ve el contenido principal y lo empieza a describir, es decir, está utilizando las imágenes de referencia que capturó con el
+
+00:06:29.160 --> 00:06:37.210
+MCP de Playwright como contexto para poder trabajar. El MCP de Notion lo que nos va a permitir es poder leer documentación que se está
+
+00:06:37.210 --> 00:06:45.940
+haciendo en el equipo y traerla como contexto. ¿Qué pasa? Cuando, por ejemplo, un PM o un diseñador está describiendo el producto que se debe
+
+00:06:45.940 --> 00:06:55.980
+desarrollar, usualmente crea una documentación. Notion lo que permite es gestionar esa documentación de una forma bastante efectiva y bonita y también habilita un servidor
+
+00:06:55.980 --> 00:07:03.800
+MCP para dar contexto a los modelos. Vamos al sitio web de Notion para saber cómo instalar su servidor MCP. En este enlace, en la
+
+00:07:03.800 --> 00:07:11.360
+sección que está de enlaces y recursos, está la forma de conectarse al servidor MCP de Notion. Aquí nos va a explicar paso a paso
+
+00:07:11.360 --> 00:07:20.400
+cómo hacerlo. También en la documentación de Cloud Code, que también está en la sección de enlaces y recursos, están una lista de servidores MCPs
+
+00:07:20.400 --> 00:07:29.580
+y la forma que tenemos para conectarnos a esos servidores MCPs. Aquí, en esta lista, está Notion. Entonces, lo podemos buscar y tenemos el comando
+
+00:07:29.580 --> 00:07:39.710
+completo. En este caso, estamos viendo que el transporte que está usando este servidor es HTTP. Entonces, podemos copiarlo, regresamos a la terminal y pegamos
+
+00:07:39.710 --> 00:07:52.740
+este comando . Pegamos el comando , vamos a ver la lista de servidores MCP que tenemos disponible y vemos que tenemos a Playwright y
+
+00:07:52.740 --> 00:08:00.680
+aquí está haciendo el chequeo con Notion y me dice que ya está conectado. Entonces, regresamos a la conversación que teníamos con Claude y vamos
+
+00:08:00.680 --> 00:08:11.840
+a revisar los servidores MCP que están. Aquí pasa algo relevante y es que Notion necesita autenticarse. En cambio, Playwright no tiene una sesión como
+
+00:08:11.840 --> 00:08:20.680
+tal, no es un sitio que necesite estar autenticado. En este caso, Notion permite hacer la reautenticación de la sesión. Yo puedo hacer un clear
+
+00:08:20.680 --> 00:08:30.280
+también. Hagamos el ejemplo . MCP me va a aparecer la lista y aquí en Notion me va a salir la sección para autenticar. Voy
+
+00:08:30.280 --> 00:08:39.600
+a darle clic... Y aquí me sale la lista de los workspaces de Notion con el que yo me quiero conectar. En este caso, voy
+
+00:08:39.600 --> 00:08:47.460
+a acceder a este plan, que es mi plan personal. Yo le digo que sí reconozco esto porque esta es la URL que monta Cloud
+
+00:08:47.460 --> 00:08:56.600
+Code para hacer la autenticación. Le digo que lo reconozco y que continúe . Aquí me dice que la autenticación fue satisfactoria. Entonces, regresemos a
+
+00:08:56.600 --> 00:09:05.319
+la terminal y veamos cómo terminó. Excelente. Dice que ya fue exitosa la autenticación. Lo podemos certificar e-ejecutando el comando MCP y vemos que ambos
+
+00:09:05.319 --> 00:09:15.520
+están conectados. Ahora, ¿cómo se utiliza el MCP de Notion? Podemos decirle, eh, que lea o que utilice el MCP de Notion para leer cierto
+
+00:09:15.520 --> 00:09:24.740
+documento. Aquí hay un archivo de ejemplo en el que yo intenté describir cómo un product manager o un diseñador hace la descripción del feature
+
+00:09:24.740 --> 00:09:32.680
+de ratings. Vemos que tiene una descripción general, cuál es el contexto técnico y cuál es el componente principal de esta vista. En Notion se
+
+00:09:32.680 --> 00:09:40.940
+puede hacer share y compartir el link. Voy a copiarlo y lo voy a pegar dentro de Cloud Code para ver cómo hace la lectura
+
+00:09:40.940 --> 00:09:52.540
+de este archivo. Aquí le doy una instrucción simple: «Utiliza el MCP de Notion para traer la documentación de este link». Le pego el link
+
+00:09:52.540 --> 00:10:00.200
+y aquí vemos que va a hacer uso de las herramientas que tiene el MCP de Notion. Aquí me va a pedir permiso para traer
+
+00:10:00.260 --> 00:10:06.780
+un ID de Notion, entonces yo le voy a decir que sí, que lo puedo utilizar por el resto de la sesión. Y acá vemos
+
+00:10:06.780 --> 00:10:16.319
+que está trayendo un, eh, objeto json con lo que nosotros tenemos dentro de la documentación de Notion, que es el título y el texto.
+
+00:10:16.319 --> 00:10:26.480
+Entonces, ya es una forma de agregarle más contexto al modelo sobre lo que queremos hacer, no únicamente revisarlo con el MCP de Playwright, sino
+
+00:10:26.480 --> 00:10:35.060
+también certificar que la expectativa que se nos está dando en la documentación se cumple. Como último ejemplo, vamos a agregar el MCP de Linear,
+
+00:10:35.060 --> 00:10:43.020
+que es una herramienta de gestión de tareas. Esta es una herramienta que permite hacer la gestión de todos los to do que tenemos por
+
+00:10:43.020 --> 00:10:51.279
+proyecto, algo muy estándar en la industria, que es que se te asigne una tarea y la ejecutas y vas actualizando el estatus de cada
+
+00:10:51.280 --> 00:10:58.860
+una de ellas. En este sitio vemos la documentación de Linear sobre cómo instalar el servidor MCP. El enlace te lo dejo en la sección
+
+00:10:58.860 --> 00:11:07.140
+de recursos y enlaces. Vemos que aquí tenemos la forma rápida de llegar a la instalación de Linear para Cloud. Y aquí abajo está el
+
+00:11:07.140 --> 00:11:15.900
+comando. Entonces, lo vamos a copiar y lo vamos a instalar. Vemos que en este caso el transport que está utilizando ya no es HTTP,
+
+00:11:15.900 --> 00:11:26.370
+sino server side events. Entonces, estamos haciendo la implementación de distintos servidores MCPs con distinto transporte, pero que también funcionan de la misma forma para
+
+00:11:26.370 --> 00:11:41.560
+agregar contexto a la conversación de Cloud Code. Salimos, pegamos... Entramos de nuevo a la conversación... Y vemos que, al igual que Notion, Linear necesita
+
+00:11:41.560 --> 00:11:52.839
+una autenticación. Podemos limpiar la autenticación y volver a reautenticar. Vamos para acá, nos dice que autentiquemos y se nos va a abrir una ventana
+
+00:11:52.839 --> 00:12:01.219
+del navegador. En esta ventana, lo que va a permitir es darle reaccesos a Cloud Code para revisar lo que está dentro de Linear. Yo
+
+00:12:01.220 --> 00:12:10.020
+le voy a decir que sí, que lo apruebo. Se abre, en este caso, la ventana en el que la autenticación fue satisfactoria y eso
+
+00:12:10.020 --> 00:12:21.140
+significa que ya podemos utilizar el MCP dentro de Cloud Code. Podemos decirle en un prompt que: «Revisa, usando el MCP de Linear, cuáles son
+
+00:12:21.140 --> 00:12:32.329
+las tareas que tengo asignadas». Aquí me pide permiso para traer o utilizar la lista de issues que están asignados a mí. Yo le voy
+
+00:12:32.329 --> 00:12:37.420
+a decir que sí, que lo permito por el resto de la sesión y en este caso está vacío. Entonces, no hay nada de qué
+
+00:12:37.420 --> 00:12:46.440
+preocuparnos. Pero si tuviéramos una lista bastante grande de tareas que hacer, la podemos gestionar desde acá. Entonces, el flujo que quiero que te imagines
+
+00:12:46.440 --> 00:12:54.819
+es el siguiente: tengo la documentación de qué es lo que tengo que hacer en Notion. Lo traigo como contexto a Cloud Code. Con Cloud
+
+00:12:54.819 --> 00:13:03.640
+Code, a partir de los user agents, creo un plan de implementación completo. Y con ese plan creo las tareas en Linear para hacer la
+
+00:13:03.640 --> 00:13:13.319
+gestión de tickets. Es muy poderoso y es bastante relevante porque simplifica mucho el trabajo de un desarrollador, que no solamente es trabajar o escribir
+
+00:13:13.319 --> 00:13:21.598
+código, sino también hacer todo un análisis completo de qué tengo que hacer y de cómo lo tengo que hacer. Los MCPs fueron construidos y
+
+00:13:21.600 --> 00:13:28.980
+diseñados para ampliar las capacidades de los modelos de lenguaje. Déjame en la sección de comentarios qué MCPs conocen y en qué casos te han
+
+00:13:28.980 --> 00:13:37.000
+funcionado. También te dejaré un listado de los servidores MCPs más relevantes que hay actualmente en el mercado para que lo puedas revisar, instalar y
+
+00:13:37.000 --> 00:13:39.219
+utilizar. Nos vemos en la próxima clase.
+

Curso de Claude Code/03-Módulo 3 Gestión de Contexto y Comandos/01-Lecturas recomendadas.txt

@@ -0,0 +1,6 @@
+https://docs.claude.com/en/docs/claude-code/mcp
+https://platzi.com/cursos/mcp/
+https://github.com/microsoft/playwright-mcp
+https://developers.notion.com/docs/get-started-with-mcp
+https://linear.app/docs/mcp
+https://modelcontextprotocol.io/docs/getting-started/intro