El Loop de ShadCN Es La Mejor Solución Para Tu UI Rota

AAI LABS
Computing/SoftwareSmall Business/StartupsInternet Technology

Transcript

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..

Key Takeaway

El bucle Ralph de Anthropic combinado con desarrollo guiado por pruebas y un protocolo estricto de verificación de capturas de pantalla resuelve los problemas de interfaces de usuario rotas cuando se construyen aplicaciones con ShadCN usando agentes de IA.

Highlights

El bucle Ralph de Anthropic permite que los agentes de IA completen tareas de forma iterativa sin abandonarlas prematuramente

El desarrollo guiado por pruebas (TDD) combinado con el bucle Ralph mejora significativamente la construcción de interfaces de usuario con ShadCN

Los agentes de IA se vuelven poco confiables con contextos grandes y tienden a abandonar tareas, por eso necesitan bucles agénticos

El protocolo de verificación de capturas de pantalla con prefijos 'verified' garantiza que todos los errores de UI sean revisados antes de completar la tarea

La promesa de finalización ('complete') evita que Claude renuncie arbitrariamente y asegura que trabaje hasta terminar realmente

Separar la verificación de imágenes de las pruebas funcionales requiere al menos dos iteraciones del bucle para garantizar calidad

Timeline

El problema de usar IA con ShadCN

El video introduce ShadCN como una de las bibliotecas de UI más utilizadas, pero señala problemas al usar agentes de IA para desarrollar con ella. Mientras que las páginas de aterrizaje simples funcionan bien, al construir aplicaciones complejas o implementar nuevas funciones, las cosas se rompen y afectan otras partes de la aplicación. Los agentes de IA intentan probar el código que escriben, pero se vuelven poco confiables con contextos grandes. Se necesita una forma de asegurar que los agentes completen el trabajo asignado, aquí es donde entran los bucles agénticos y específicamente el bucle Ralph de Anthropic.

Introducción al bucle Ralph

Ralph es un nuevo plugin lanzado por Anthropic basado en una técnica de otra persona que ellos implementaron y liberaron como código abierto. Ralph es un bucle que usa los ganchos de detención de Claude Code que se ejecutan cuando Claude deja de generar una respuesta. Tan pronto como se detiene, el agente de IA recibe su archivo de prompt inicial nuevamente, permitiéndole mejorar su trabajo de manera iterativa. El bucle se detiene cuando Claude emite una 'promesa de finalización', que puede ser cualquier palabra configurada (en este caso 'complete'). Esto asegura que Claude no renuncie simplemente cuando quiera, sino que continúe trabajando hasta que realmente complete la tarea.

Comandos y mejores prácticas del bucle Ralph

Después de instalar el plugin, se obtienen tres comandos: el comando de bucle Ralph, uno de cancelación y uno de ayuda. En el comando de bucle se proporciona el prompt que se alimenta al agente repetidamente. Es importante establecer un conteo máximo de iteraciones porque a veces Claude puede recibir una tarea imposible y quedarse atascado en un bucle infinito. El video menciona que el repositorio incluye buenas prácticas para los prompts que se pueden dar al bucle Ralph. El enfoque del video será discutir específicamente las mejores prácticas relacionadas con el flujo de trabajo de interfaz de usuario que se va a demostrar.

Desarrollo guiado por pruebas (TDD) explicado

El video introduce dos funciones a implementar: una paleta de comandos para buscar y ejecutar comandos, y una vista de tablero similar a Notion. Para asegurar que estas funciones no rompan otras partes de la aplicación, se comienza con pruebas usando desarrollo guiado por pruebas (TDD). Claude Code puede configurar la estructura TDD automáticamente, creando carpetas de pruebas de extremo a extremo y capturas de pantalla para verificar problemas de UI. El TDD es un enfoque donde las pruebas se escriben antes de implementar el código, lo que significa que las pruebas iniciales siempre fallarán. Primero se escriben pruebas elaboradas, luego se escribe la cantidad mínima de código para pasarlas, y finalmente se refactoriza agregando más funcionalidad mientras se asegura que las pruebas sigan pasando.

Verificación visual y automatización con Playwright

Las pruebas son automatizadas y Playwright puede ser importado para verificación visual. A diferencia de usar el MCP de Playwright para verificar autónomamente a través del navegador, con TDD se toman capturas de pantalla para cada comportamiento funcional. Por ejemplo, si el comportamiento funcional es agregar una tarjeta, la captura de pantalla mostrará una tarjeta agregada al tablero. El agente de IA solo tiene que mirar esas capturas de pantalla y asegurarse de que no haya problemas en la implementación de los componentes de ShadCN. Estos archivos de prueba aseguran que cada vez que se agrega algo nuevo, todos los requisitos de comportamiento se cumplen, pero las capturas de pantalla se usan puramente para verificación de UI.

Por qué necesitamos el bucle Ralph con TDD

Aunque ya existe TDD, el bucle Ralph es necesario porque con tareas más grandes y ventanas de contexto casi llenas, los modelos abandonan abruptamente sus tareas y requieren entrada humana constante. Se pueden escribir pruebas de antemano para cualquier función, luego usar el bucle para instruir al agente sobre qué hacer y puede trabajar de forma autónoma. Se le indica qué flujo de trabajo seguir y la condición para emitir la promesa. Cuando completa la tarea y pasa todas las pruebas (en este caso 25 pruebas únicas), emite la promesa y sale del bucle, logrando autonomía completa en la implementación.

Implementación de la paleta de comandos

Usando el comando de Ralph, se proporcionó un prompt para construir iterativamente la función de paleta de comandos. El prompt incluía requisitos básicos (aunque estos también estaban en las pruebas) y delineaba todo el flujo de trabajo. El flujo de trabajo consistía en: ejecutar las pruebas (que fallarían inicialmente), implementar los componentes para hacerlas pasar, revisar capturas de pantalla de la interfaz de usuario para asegurar implementación correcta de ShadCN, y ejecutar las pruebas nuevamente para confirmar que aún pasaban después de los cambios de UI. Como esta era una tarea más pequeña, Claude pudo implementar todo de una vez, escribir todos los componentes y hacer que todas las pruebas pasaran. Después de revisar las capturas de pantalla y confirmar que todo funcionaba, emitió la promesa de finalización y el bucle se detuvo.

Problema descubierto con la vista de tablero

No hubo problemas con la paleta de comandos porque había pocas posibilidades de errores de UI, pero al implementar la vista de tablero se descubrió un error enorme en el sistema. Usando el mismo prompt con requisitos diferentes pero flujo de trabajo similar, Claude completó todos los requisitos de una vez y aseguró que las pruebas pasaran. Sin embargo, había casos donde el número de pruebas exitosas disminuía porque al cambiar algo se rompía algo más, demostrando la importancia del TDD. El problema principal fue que después de verificar que estaba terminado, al revisar la UI había errores que Claude había perdido completamente. Los errores eran visibles en las capturas de pantalla, pero Claude los había ignorado y emitió la promesa prematuramente sin verificar realmente si la UI estaba arreglada.

Análisis del fallo del proceso

El análisis reveló que el problema fue una falla del proceso, específicamente en términos de arreglar la interfaz de usuario. Claude sí pasó todas las pruebas porque se suponía que debía ejecutar los archivos de prueba repetidamente, pero no había una prueba específica para la UI aparte de las capturas de pantalla. Claude echó un vistazo a algunas capturas de pantalla e ignoró errores de UI que había visto, y algunos archivos fueron completamente ignorados. El problema principal fue que emitió su declaración de promesa prematuramente sin verificar si la UI estaba realmente arreglada. Se realizó una sesión de lluvia de ideas usando las mejores prácticas del repositorio para llegar a reglas específicas y un cambio en el proceso que aseguraría que la UI siempre fuera correcta.

Solución: protocolo de verificación mejorado

Se cambiaron varias cosas en el prompt principal. La primera fue el protocolo de verificación de capturas de pantalla: se agregó un prefijo simple a cada imagen indicando a Claude si había leído la captura de pantalla o no. En la primera implementación, Claude todavía no leía todas las imágenes, solo algunas, escribía 'verified' encima y renunciaba temprano. Para resolver esto se le alentó a pensar diferente: después de renombrar todas las capturas de pantalla, no debería emitir la promesa todavía, lo que significa que no debería considerar la tarea completada. La siguiente iteración confirmaría la finalización, garantizando que al menos dos bucles se ejecuten. Las pruebas se cambiaron para separar la verificación de imágenes de las pruebas funcionales.

Resultado exitoso con el proceso mejorado

La siguiente iteración se asegura de que todas las imágenes tengan el prefijo 'verified' y si Claude pierde alguna, las mira de nuevo y corrige la salida. Con este cambio, los pequeños errores de interfaz de usuario finalmente se corrigieron y pudo implementar todas las funciones correctamente. En el siguiente bucle, Claude ejecutó las pruebas de nuevo, encontró algunos errores y los corrigió. Debido a que todos los archivos tenían la palabra 'verified', ejecutó una prueba final. Esta vez completó su tarea en dos bucles y pudo corregir todos los errores importantes de interfaz de usuario en la aplicación, demostrando la efectividad del proceso mejorado.

Promoción de Automata y cierre

El video concluye con una promoción de Automata, el servicio del creador que ayuda a dar vida a ideas mediante aplicaciones o sitios web. Después de enseñar a millones de personas cómo construir con IA, implementan estos flujos de trabajo ellos mismos y descubrieron que pueden construir mejores productos más rápido que nunca. Se posicionan como copiloto técnico para quienes tienen ideas pero no tienen equipo técnico, aplicando los mismos flujos de trabajo enseñados en sus videos para convertir conceptos en soluciones reales sin los dolores de cabeza de contratar o gestionar un equipo de desarrollo. Invita a contactarlos en hello@automata.dev y agradece el apoyo mediante el botón de Super Thanks.

Community Posts

View all posts