00:00:00La mayoría de ustedes ya conocen shad cn como una de las bibliotecas de interfaz de usuario más utilizadas,
00:00:04pero usar un agente de IA para desarrollar con ella puede ser problemático.
00:00:08Si estás construyendo páginas de aterrizaje de una sola vez,
00:00:10no tendrás un problema enorme,
00:00:12pero si estás construyendo una nueva aplicación o implementando una nueva función,
00:00:15las cosas se rompen y también rompen otras partes de la aplicación.
00:00:18Pero esto no es nada nuevo,
00:00:20este problema ya ha sido resuelto y es cómo los ingenieros construyen aplicaciones ahora.
00:00:24Los agentes de IA siempre prueban el código que escriben,
00:00:26pero estos agentes se vuelven poco confiables con contextos grandes.
00:00:29Por lo tanto,
00:00:30necesitamos una forma de asegurar que los agentes completen el trabajo que se les asigna.
00:00:34Aquí es donde entra el concepto de bucles agénticos,
00:00:36y Anthropic resuelve esto usando el bucle Ralph.
00:00:38Para resolver mi problema de interfaz de usuario,
00:00:40intenté implementar el bucle Ralph y al principio falló completamente,
00:00:43pero pronto aprendí que no era por culpa del bucle Ralph,
00:00:46sino por el proceso que había implementado con él.
00:00:48Así que Ralph es en realidad un nuevo plugin que ha sido lanzado por la propia Anthropic,
00:00:52pero esta no fue una de sus ideas originales.
00:00:54Se basa en una técnica de otra persona y Anthropic lo implementó y lo hizo de código abierto.
00:00:58Básicamente,
00:00:59Ralph es un bucle y si conoces los ganchos de código de Claude,
00:01:01usa estos ganchos de detención que se ejecutan cuando Claude deja de generar una respuesta.
00:01:06Tan pronto como se detiene,
00:01:07el agente de IA recibe su archivo de prompt inicial nuevamente y esto le permite mejorar su trabajo de manera iterativa.
00:01:12Ahora,
00:01:13aquí está la pregunta importante: ¿cuándo sale realmente del bucle?
00:01:16Hay algo llamado promesa de finalización,
00:01:17que puede ser cualquier palabra que ingreses.
00:01:19Cuando Claude siente que su tarea está completada,
00:01:22emite esta promesa por sí mismo.
00:01:23Por ejemplo,
00:01:23en este caso la promesa es la palabra "complete".
00:01:26Si la promesa está en el prompt de retorno,
00:01:28entonces el bucle no se ejecuta de nuevo.
00:01:29Así que hasta que Claude emita una promesa, no se detiene.
00:01:32Esto asegura que Claude no renuncie simplemente cuando quiera.
00:01:35Después de instalar el plugin,
00:01:36tendrás tres comandos: el comando de bucle Ralph,
00:01:38un comando de cancelación y un comando de ayuda.
00:01:40En el comando de bucle necesitas proporcionar el prompt que se alimenta al agente una y otra vez.
00:01:45A veces puede obtener una tarea imposible que no puede resolver y podría quedarse atascado en un bucle infinito,
00:01:50así que establecer un conteo máximo de iteraciones es una muy buena práctica.
00:01:53Dejaré el enlace al repositorio abajo porque tienen algunas buenas prácticas para los prompts que puedes dar al bucle Ralph,
00:01:59pero en este video solo voy a discutir los relacionados con el flujo de trabajo de interfaz de usuario que voy a mostrarte.
00:02:04Así que digamos que queremos implementar dos funciones en esta aplicación.
00:02:07Una es una paleta de comandos donde agregamos un menú para buscar en nuestra aplicación y ejecutar otros comandos.
00:02:12Para asegurarnos de que esta nueva función no rompa otras partes de la aplicación,
00:02:16comenzarías con las pruebas.
00:02:17Esto se llama desarrollo guiado por pruebas.
00:02:19Si no estás familiarizado con esto,
00:02:21puedes pedirle a Claude Code que configure la estructura TDD para ti,
00:02:24donde crea una carpeta de pruebas de extremo a extremo,
00:02:26una carpeta de capturas de pantalla para verificar problemas de interfaz de usuario y la prueba correspondiente también.
00:02:32La otra función que vamos a implementar es una vista de tablero en la base de datos similar a lo que Notion nos permite hacer con sus bases de datos.
00:02:38Si has entendido,
00:02:39el desarrollo guiado por pruebas es un enfoque donde las pruebas se escriben antes de que se implemente el código,
00:02:44pero esto significa que las pruebas iniciales siempre fallarán.
00:02:47Así que si estoy implementando la función de paleta de comandos,
00:02:50no comenzaría simplemente escribiendo el código para ello.
00:02:52En su lugar,
00:02:53primero escribiría pruebas elaboradas para ello.
00:02:55Luego escribimos la cantidad mínima de código requerida para pasar esas pruebas.
00:02:59Una vez hecho esto,
00:02:59refactorizamos y agregamos más funcionalidad,
00:03:01y con cada adición nos aseguramos de que las pruebas sigan pasando.
00:03:04Otra cosa interesante es que estas pruebas son automatizadas y Playwright puede ser importado y usado para verificación visual.
00:03:10Si piensas que estamos usando el MCP de Playwright para verificar esto de forma autónoma a través del navegador,
00:03:15estás equivocado.
00:03:16Con TDD,
00:03:16para cada comportamiento funcional puedes tomar capturas de pantalla.
00:03:20Por ejemplo,
00:03:20si el comportamiento funcional es agregar una tarjeta,
00:03:22entonces la captura de pantalla mostraría una tarjeta agregada al tablero.
00:03:26Así que ahora todo lo que el agente de IA tiene que hacer es mirar esas capturas de pantalla y asegurarse de que no haya problemas en la forma en que estos componentes de shad cn han sido implementados.
00:03:35Estos archivos de prueba aseguran que cada vez que se agrega algo nuevo o mientras se está construyendo una función,
00:03:40todos nuestros requisitos de comportamiento se cumplen.
00:03:42Pero en nuestro caso queremos usar las capturas de pantalla puramente para verificación de interfaz de usuario.
00:03:47Pero si ya tenemos TDD, ¿por qué necesitamos el bucle Ralph?
00:03:50Como ya he dicho,
00:03:51con tareas más grandes y ventanas de contexto que se llenan casi por completo,
00:03:54estos modelos abandonan abruptamente sus tareas y requieren entrada humana constante.
00:03:58Por lo tanto,
00:03:59puedo tener pruebas escritas de antemano para cualquier tipo de función que quiera,
00:04:02luego usar el bucle para instruirle sobre qué hacer y puede trabajar de forma autónoma diciéndole qué flujo de trabajo seguir y luego dándole la condición para cuando pueda emitir la promesa.
00:04:11Completa la tarea y sale del bucle,
00:04:12que en este caso es cuando pasa las 25 pruebas únicas.
00:04:15Así que usando el comando de barra de Ralph,
00:04:17le di un prompt para que construyera iterativamente la función de paleta de comandos.
00:04:21En el prompt básicamente le estábamos diciendo que implementara la función junto con algunos requisitos básicos que no son realmente importantes porque los requisitos también se pueden encontrar en las pruebas,
00:04:30pero sí delineamos todo el flujo de trabajo.
00:04:32En ese flujo de trabajo se suponía que comenzaría ejecutando las pruebas.
00:04:35Sabe que las pruebas fallarán y después de eso necesita implementar los componentes para hacerlas pasar.
00:04:40Así que ese es todo el objetivo.
00:04:41Ahora,
00:04:42si esta fuera una tarea mucho más amplia,
00:04:44es probable que cuando la ventana de contexto se llene o Claude se confunda,
00:04:47renunciará automáticamente.
00:04:48Nunca emitirá la promesa de finalización y como nunca emite la promesa,
00:04:51el prompt se volverá a alimentar y tendrá que empezar de nuevo,
00:04:54lo que significa que seguirá trabajando en ello de forma iterativa.
00:04:57Pero como esta era una tarea más pequeña,
00:04:59en realidad pudo implementar todo de una sola vez,
00:05:01escribir todos los componentes y hacer que todas las pruebas pasaran.
00:05:04Ahora,
00:05:05después de que las pruebas pasan,
00:05:06el flujo de trabajo le dice que revise todas las capturas de pantalla de la paleta de comandos.
00:05:11Estas son capturas de pantalla tomadas en diferentes etapas para asegurarse de que la interfaz de usuario,
00:05:15ya sea shad cn o cualquier otra biblioteca de componentes que estés usando,
00:05:19esté implementada correctamente y que no haya problemas menores.
00:05:21Después de eso,
00:05:22debe ejecutar las pruebas nuevamente y asegurarse de que aún pasen después de los cambios de interfaz de usuario.
00:05:27Como todas las pruebas estaban pasando y las capturas de pantalla fueron revisadas,
00:05:31emitió la promesa de finalización.
00:05:32Aquí es donde el bucle se detuvo y no continuó de nuevo.
00:05:35Pero hubo un problema realmente grande con esto que no noté en la función de paleta de comandos porque había muy pocas posibilidades de errores de interfaz de usuario allí.
00:05:42Sin embargo,
00:05:43cuando pasé a implementar la vista de tablero,
00:05:45me di cuenta de que había un error enorme en el sistema.
00:05:47Comencé implementando el tablero con el mismo prompt.
00:05:50Los requisitos eran diferentes,
00:05:51por supuesto,
00:05:52pero el flujo de trabajo era prácticamente el mismo.
00:05:54Ahora me sorprendió un poco cuando completó todos los requisitos de una sola vez.
00:05:58No me malinterpretes,
00:05:59en realidad estaba asegurándose de que todas las pruebas estuvieran pasando,
00:06:02pero mientras lo hacía,
00:06:03había casos en los que el número de pruebas exitosas en realidad disminuía porque al cambiar algo rompía algo más,
00:06:08y es por eso que TDD es realmente importante debido a esta prueba recursiva y asegurándose de que todo funcione.
00:06:13Pero el problema principal era que después de que había verificado que estaba terminado y yo fui y verifiqué la interfaz de usuario,
00:06:19la mayoría de las cosas estaban implementadas correctamente,
00:06:22pero había perdido completamente algunos errores de interfaz de usuario como este.
00:06:25También verifiqué las capturas de pantalla y los errores se mostraban en esas capturas de pantalla también.
00:06:30Así que le pregunté y analizamos qué salió realmente mal.
00:06:33El problema real fue una falla del proceso,
00:06:35específicamente en términos de arreglar la interfaz de usuario.
00:06:37Lo que sucedió fue que sí pasó todas las pruebas porque se suponía que debía ejecutar los archivos de prueba una y otra vez,
00:06:43pero no había una prueba específica para la interfaz de usuario aparte de las capturas de pantalla.
00:06:47Echó un vistazo a algunas de ellas e incluso ignoró algunos de los errores de interfaz de usuario que había visto.
00:06:52Algunos archivos fueron completamente ignorados.
00:06:55Así que el problema principal fue que emitió su declaración de promesa prematuramente y no verificó si la interfaz de usuario estaba realmente arreglada.
00:07:01Pasamos por toda una sesión de lluvia de ideas sobre cómo podríamos arreglar esto e incluso le di las mejores prácticas de escritura de prompts del repositorio a Claude Code,
00:07:09pero al final llegamos a algunas reglas específicas y un cambio en el proceso que aseguraría que la interfaz de usuario siempre fuera correcta.
00:07:15Ahora esto no tenía nada que ver con las pruebas porque siempre van a ejecutarse.
00:07:19El prompt que usamos para la paleta de comandos es realmente útil cuando la función o implementación es muy grande donde Claude no alucina que ha completado la tarea,
00:07:26sino que debido a una ventana de contexto completa o la complejidad de la tarea,
00:07:30renuncia abruptamente.
00:07:31Ahora Claude Code ya es realmente autónomo,
00:07:33no hay duda sobre eso,
00:07:34pero todavía hay problemas como este que necesitamos arreglar.
00:07:37Así que cambiamos varias cosas en el prompt principal.
00:07:39La primera fue el protocolo de verificación de capturas de pantalla.
00:07:42Agregamos un prefijo simple a cada imagen que le decía a Claude si había leído la captura de pantalla o no.
00:07:47Pero cuando lo implementé por primera vez,
00:07:49todavía no leía todas las imágenes.
00:07:50Leería algunas,
00:07:51escribiría "verified" encima de ellas y al igual que antes,
00:07:54renunciaría temprano.
00:07:55Así que para resolver esto lo alentamos a pensar de una manera diferente.
00:07:58Le dijimos que después de que renombrara todas las capturas de pantalla,
00:08:01no debería emitir la promesa todavía,
00:08:03lo que significa que no debería considerar la tarea completada y debería dejar que la siguiente iteración confirme la finalización.
00:08:09Así que al menos dos bucles deberían ejecutarse.
00:08:11Lo que sucede en la siguiente verificación es que Claude verifica que todos los archivos tengan el prefijo
00:08:15"verified"
00:08:16.
00:08:16Por supuesto,
00:08:17esto significaba que teníamos que cambiar las pruebas y separar la verificación de imágenes de las pruebas funcionales.
00:08:22La siguiente iteración se asegura de que todas las imágenes tengan resultados verificados y si Claude pierde alguna,
00:08:27las mira de nuevo y corrige la salida.
00:08:29Con este cambio,
00:08:30los pequeños errores de interfaz de usuario que estábamos enfrentando finalmente se corrigieron y pudo implementar todas estas funciones correctamente.
00:08:37Así que cuando entró en el siguiente bucle,
00:08:38ejecutó las pruebas de nuevo.
00:08:40Como encontró algunos errores,
00:08:41los corrigió y debido a que todos los archivos tenían la palabra "verified" en ellos,
00:08:45ejecutó una prueba final.
00:08:46Esta vez completó su tarea en dos bucles y pudo corregir todos los errores importantes de interfaz de usuario en la aplicación.
00:08:52Hablemos de Automata ahora.
00:08:53Después de enseñar a millones de personas cómo construir con IA,
00:08:56comenzamos a implementar estos flujos de trabajo nosotros mismos.
00:08:59Descubrimos que podíamos construir mejores productos más rápido que nunca.
00:09:02Ayudamos a dar vida a tus ideas,
00:09:03ya sean aplicaciones o sitios web.
00:09:05Tal vez has visto nuestros videos pensando
00:09:07"tengo una gran idea pero no tengo un equipo técnico para construirla"
00:09:10.
00:09:10Ahí es exactamente donde entramos nosotros.
00:09:12Piensa en nosotros como tu copiloto técnico.
00:09:14Aplicamos los mismos flujos de trabajo que hemos enseñado a millones directamente a tu proyecto,
00:09:18convirtiendo conceptos en soluciones reales y funcionales sin los dolores de cabeza de contratar o gestionar un equipo de desarrollo.
00:09:24¿Listo para acelerar tu idea hacia la realidad?
00:09:26Contáctanos en hello@automata.dev.
00:09:28Si te gustaría apoyar el canal y ayudarnos a seguir haciendo videos como este,
00:09:31puedes hacerlo usando el botón de Super Thanks abajo.
00:09:34Como siempre, gracias por ver y te veré en el próximo..