Técnicas Avanzadas de Claude Code: Ingeniería Agente con Desarrollo Impulsado por Contexto

¡Bienvenidos a todos! Tengo dos preguntas antes de comenzar. Necesito un poco de ingeniería de contexto para mí mismo aquí. Así que levanten la mano si han usado un asistente de codificación de IA antes. Bien, la mayoría de la sala, eso es bueno. De lo contrario, tendríamos un problema. Muy bien, ahora levanten la mano si usan uno para la mayoría, si no es que para todo su desarrollo ahora. Bien, eso también es lo que esperaba. No muchos. Muy bien, bien. Así que eso es lo que esperaba. Así que bienvenidos a su guía sobre ingeniería de contexto.

Y la ingeniería de contexto es un tema muy, muy amplio. Y realmente, se trata de desarrollar estrategias para dar el contexto a su asistente de codificación sobre su proyecto y lo que quieren construir, y lo suficiente para que tenga lo necesario para hacer el trabajo. Y dado que es un tema tan amplio, quiero centrarme específicamente en lo que están viendo aquí. Eso es usar los errores a nuestro favor, construyendo un asistente de codificación de IA que pueda autoevolucionar. Y lo que quiero darles a ustedes hoy, mi objetivo es darles muchas cosas sobre las que puedan actuar de inmediato. Y también hacer que sea realmente fácil de entender lo que estoy presentando aquí, pero aún así quiero que sea realmente poderoso al mismo tiempo.

Así que voy a mover mi ratón para ir entre las diapositivas aquí, porque no quiero quedarme en mi computadora todo el tiempo. Y antes de entrar en el meollo del asunto. Ahí vamos, quiero presentarme un poco. Así que soy un educador de IA, consultor y creador de contenido. Y principalmente me encontrarán en mi canal de YouTube, que comencé hace poco más de un año, y ya lo he hecho crecer a 175,000 suscriptores, lo cual todavía es increíble para mí, como que soy el más sorprendido de hasta dónde ha llegado en este punto. Y luego allí y también en mi comunidad privada de IA, me enfoco en enseñar cómo construir agentes de IA y aprovechar la asistencia de codificación de IA de una manera que realmente escale.

Y he sido ingeniero prácticamente toda mi vida, desde que tenía ocho años, levanten la mano de nuevo, si han oído hablar del lenguaje de programación Scratch desarrollado por MIT, probablemente no lo usen ahora para nada de grado de producción, es un tipo de lenguaje de programación de construcción de bloques que usé de niño para crear videojuegos. Y ahí es donde comencé mi ingeniería.

Y desearía poder decir que he estado construyendo agentes de IA y usando asistencia de codificación de IA durante tanto tiempo también. Pero sí, realmente no pude hacer eso hace más de tres años. Pero hace tres años es cuando comencé a involucrarme muy intensamente en la IA generativa, prácticamente justo cuando explotó con el lanzamiento de GPT 3.5. Turbo en noviembre de 2022. Y he estado construyendo todo con IA desde entonces, todas las oportunidades que han surgido de mi canal, personas pidiéndome que construya desde automatizaciones personales hasta implementaciones locales de IA a nivel empresarial.

Y podría sorprenderles lo que estoy a punto de decir, especialmente dado de lo que estoy hablando aquí. Pero incluso el año pasado, era muy reacio a usar la asistencia de codificación de IA, todos los ingenieros que conocía estaban comenzando a depender realmente mucho de Windsor of Cursor, GitHub, Copilot, todas estas diferentes herramientas, y me negué a usarlas durante un largo tiempo, usaría modelos de lenguaje grandes para ayudarme a planificar mi desarrollo. Creo que todos deberían absolutamente estar haciendo eso sin importar qué.

para mí mismo, ¿por qué confiaría la implementación a un asistente de codificación de IA, si puedo hacerlo mejor? Y son tan impredecibles. Eso es lo que pensaba. Ahora, obviamente, ya que estoy aquí, en este momento, mi comprensión ha evolucionado, y también lo han hecho mis sistemas. Y eso es realmente en lo que quiero centrarme hoy. La razón por la que no confiaba en la asistencia de codificación de IA en el pasado es por el problema de las correcciones puntuales. Y así es como operan la mayoría de los desarrolladores, usan un asistente de codificación de IA para ayudarles a construir algo. Y luego, cuando encuentran un problema, porque los modelos de lenguaje grandes nunca van a ser perfectos, simplemente corrigen el error ellos mismos y siguen adelante. Pero el problema con eso es que se encuentran con lo mismo una y otra vez.

Y voy a ser realista, hay muchas de esas cosas con las que te encontrarás una y otra vez, como que tu asistente de codificación está instalando versiones antiguas de paquetes, está completamente sobre-ingeniando tu solución, tu implementación está súper estrechamente acoplada, como todas estas cosas que he visto una y otra vez, no voy a endulzar esta charla aquí y decir que los asistentes de codificación de IA son mágicos, y que no te encontrarás con estas cosas. Pero lo que sí te estoy diciendo es que hay una solución para todos estos problemas. Y esa es la filosofía en la que quiero centrarme hoy. Y es que cada error es una oportunidad para ti.

Así que es un ganar-ganar. Y lo que quiero decir con eso es que cuando encuentras un problema en tu código, gracias a un asistente de codificación de IA, como cloud code, y de hecho entraré en una demostración con cloud code más tarde, en lugar de simplemente corregir el error, lo cual obviamente también tienes que hacer. También es un momento para reflexionar y encontrar lo que me gusta llamar brechas del sistema, hay algún proceso que has creado para trabajar con tu asistente de codificación. Ese es el sistema al que me refiero. Son tus estrategias para investigar, planificar e implementar tu proceso de validación. Hay algo allí que puedes corregir para evitar ese problema con el que te acabas de encontrar.

No quiero decir que los modelos de lenguaje grandes no tengan a veces esa alucinación puntual o casualidad que nunca volverás a ver. Quiero decir, eso va a suceder. Pero la mentalidad productiva es pensar, está bien, si el problema fue conmigo y mi sistema, ¿qué puedo hacer para abordar esto? Y eso es lo que nos da el poder de tener nuestro sistema de codificación que puede auto-evolucionar. Y digo auto, porque podemos usar el asistente de codificación para ayudarnos a abordar estas brechas del sistema. Y así, sigo diciendo sistema, sistema, sistema, puede que sea un poco vago en tu mente lo que quiero decir con eso. Y así, antes de ser realmente concreto contigo sobre cómo se ve abordar estas brechas del sistema, quiero describir qué es un sistema. Y esto realmente es el núcleo de la ingeniería de contexto también. Y así, como mencioné anteriormente, un sistema es realmente solo el proceso que has definido para trabajar con tu agente de codificación. Y así, hay cuatro componentes principales que tengo para esto. Primero son tus reglas globales.

Estas son las restricciones y patrones de alto nivel que tienes para tu base de código. Se aplica a toda tu base de código. Como, estas son las cosas que quieres que tu asistente de codificación siga sin importar qué. Ahora, lo que pasa con las reglas globales es su contexto, es el contexto que se carga en la ventana de contexto de tu agente todo el tiempo. Así que quieres mantenerlo conciso, de lo contrario, simplemente vas a abrumar completamente al LLM. Quiero decir, el mantra clásico es que solo porque el contexto puede caber en la ventana para el LLM no significa que debas intentarlo. Porque cuanto más añades, más lo abrumas. Se llama rotura de contexto, si has oído esa frase antes. Así que quieres evitar eso. Y así, eso nos lleva al segundo componente que tenemos aquí, que es el contexto bajo demanda.

Así que, todavía son restricciones y patrones de alto nivel que queremos que nuestro asistente siga, pero es para partes específicas de nuestra base de código. Por ejemplo, tal vez tengamos una guía que describa nuestros patrones para implementar componentes de front-end. O tenemos una guía de referencia sobre cómo construimos herramientas en nuestros agentes de IA. Ese tipo de cosas que definitivamente queremos cargadas en el contexto del LLM cuando estamos haciendo ese tipo de tarea específica, pero no estamos haciendo referencia a eso todo el tiempo. Las reglas globales son cosas como nuestros patrones de registro, patrones de prueba, arquitectura, el tipo de cosas que literalmente no importa lo que estés haciendo, característica o corrección de errores, quieres que eso se cargue en el contexto.

Y luego también tenemos, en tercer lugar, nuestros comandos, que realmente llamaría el corazón del sistema. Porque tus comandos son los procesos que has escrito y ahora tienes como un aviso reutilizable, para que tengas un flujo de trabajo predecible que puedas usar una y otra vez. Al menos tan predecible como pueden ser los LLMs, ¿verdad? Ese es nuestro objetivo, es que aunque sea un sistema no determinista, intentar hacerlo tan confiable y predecible como podamos. Y luego, por último pero no menos importante, tenemos nuestros procesos de validación. ¿Cuáles son las herramientas y estrategias que podemos dar a nuestro asistente de codificación de IA para que pueda verificar su propio trabajo, encontrar errores a través de eso, y luego iterar? Así que tenemos el ciclo autónomo de no solo hacer la implementación sino realmente corregir, con suerte, muchos de los problemas que encuentra cuando desarrolla el código. Y así, ese es un sistema a un alto nivel.

Y el principal modelo mental que siempre enseño al construir sistemas para AI coding, y aquí es donde comenzaremos a ver cómo evoluciona nuestro sistema, es el bucle PIV. Así que PIV es la abreviatura de planificar, implementar y validar. Y como ingeniero, este tipo de proceso te debería resultar bastante familiar incluso fuera de usar coding agents. Pero hay algunos detalles específicos que debemos considerar cuando trabajamos con un coding agent y cómo le damos el contexto que necesita, es decir, ingeniería de contexto. Y no importa la estrategia que inventes tú mismo, o encuentres en línea, como tal vez hayas oído hablar del GitHub spec kit, o el método BeMad, o PRP, hay todas estas diferentes estrategias flotando por ahí. Todo se reduce a esto. Tienes que planificar la implementación con tu coding assistant, asegurarte de que realmente estás en la misma página sobre lo que estás construyendo, luego le das la implementación, delegas, con suerte, la mayor parte del código al asistente. Y eso es lo que hago hoy en día. Y luego al final tienes la validación, donde tanto tú como el revisan el trabajo, ejecutan las pruebas, validan las cosas manualmente. Y lo importante del bucle PIV es que no es vibe coding. Es esa frase un poco cursi que probablemente hayas escuchado una y otra vez, donde simplemente sigues la corriente y entregas toda la implementación al coding assistant y aceptas lo que sea que salga. Y la razón por la que el bucle PIV no es vibe coding es porque la implementación es lo único que estamos entregando al coding assistant. Lo estamos intercalando entre la planificación y la validación, donde somos una parte importante del proceso. Y no puedo enfatizar lo suficiente lo importante que es ser parte del proceso y no volverse perezoso allí, porque de lo contrario no será confiable. Y así, profundizando un poco más en esto para nuestra fase de planificación, comenzamos con lo que me gusta llamar planificación de vibe. Este es el único lugar donde te doy permiso para simplemente seguir la corriente.

Porque al principio, es solo una conversación exploratoria con el coding assistant. Hay una nueva característica que tienes en mente, quieres implementarla. Y tu trabajo aquí es simplemente estar en la misma página con el coding assistant para cosas como tu arquitectura, si es una base de código existente, como qué parte de la base de código tengo que tocar para construir esto, ese tipo de cosas. Y luego tu conversación pasa de ser no estructurada a muy estructurada. Así que tienes estas secciones clave que tienes en algún tipo de PRD o documento que produces al final de la planificación, o que describe la documentación externa que quieres referenciar, las partes del código que tienes que tocar, la lista de tareas para implementar esa característica, tus criterios de éxito. Si eres un product manager, vas a poder crear este tipo de plan estructurado muy bien, porque básicamente lo que estás haciendo aquí es que eres un project manager para el coding assistant. Y así, siguiendo la misma línea, tomamos ese plan estructurado y ahora lo damos para delegar el código al coding assistant en la fase de implementación. Y así, tu proceso aquí, que por cierto, todo esto se hace usando comandos para delinear cómo hacemos estas cosas, el proceso para la implementación es que el coding assistant primero leerá el plan estructurado, tomará las tareas de eso, y luego las completará una por una.

Así que comienza haciendo un poco de investigación para esa tarea, implementando el código, haciendo una rápida validación antes de pasar a la siguiente tarea. Y simplemente hace eso sistemáticamente hasta que completa todo tu plan. Y por cierto, cuando digo lista de tareas aquí, no estoy diciendo que le des como una épica completa en Jira, y simplemente complete cada tarea, como no, tu plan estructurado es para una sola tarea en algo como Jira. Así que quieres mantenerlo realmente granular, pero estos son solo como todos los subpasos individuales, como una tarea podría ser más algo como, escribir este archivo o configurar esta configuración versus implementar una característica completa, ¿verdad? Así que estamos a nivel de característica aquí. Y luego, una vez que hemos terminado con la implementación, hemos hecho un poco de validación en cada paso del camino, pero aún queremos hacer el proceso de validación más grande al final.

Y nuevamente, aquí es donde tanto nosotros como nuestro nosotros como humanos y el AI coding assistant somos responsables. Así que nuestro coding assistant como parte de nuestra estructura de comandos le dirá cómo ejecutar el linting, la verificación de tipos, pruebas unitarias, pruebas de integración, con suerte construyó algunas pruebas más cuando implementó esta nueva característica también, pero está haciendo las nuevas pruebas y pruebas de regresión. Y luego es nuestro trabajo hacer la revisión de código, y también hacer las pruebas manuales. Así que realmente ejecutar la aplicación.

Y así tuve que llegar a este punto para explicar qué es un sistema y cómo opero en un sistema. Pero ahora es donde comenzamos a entrar en cómo podemos evolucionar nuestro sistema y encontrar las brechas del sistema, porque en la fase de validación es donde tanto nosotros como el AI coding assistant encontraremos problemas que necesitamos abordar. Y no es el caso de que tengas que hacer lo que estoy a punto de cubrir aquí para cada error que encuentres. Normalmente son los que ves emerger como un patrón, como, oh, esta es la cuarta vez que ha hecho algo realmente estúpido con mis consultas SQL.

Como, tal vez hay una vulnerabilidad de inyección SQL por cuarta vez en mi código. Como, está bien, ahora probablemente debería abordar la brecha del sistema aquí. Y así encuentras el error, analizas tu sistema. Así que estás pensando en este punto, como, ¿son mis reglas las que necesitan ser actualizadas? Como, ¿hay simplemente un mejor patrón de pruebas que necesito aquí? O tal vez es mi comando de planificación, mi proceso para cómo investigo mi implementación y uso el AI coding assistant para ayudarte a averiguar qué es esto también.

Nunca depende completamente de ti. Y entonces actualizas tu sistema, cambias el comando, cambias tu contexto bajo demanda, lo que sea que pueda ser, como tal vez actualices tu guía para implementar componentes de front end para que haya una mejor estrategia de pruebas. Y luego puedes llegar a volver a intentar completamente la tarea si lo deseas. Y es un poco laborioso hacer esto. Pero, por ejemplo, si cambias tu proceso de implementación o validación, podrías borrar completamente este primer intento, volver a cuando solo tienes el plan estructurado, y luego volver a intentar toda la implementación. Y haré eso bastante para esos problemas más grandes que he visto emerger varias veces, porque es importante realmente validar que tu actualización al sistema realmente abordó el problema.

Y así, típicamente, lo que hago en un bucle PIV es planificar, crear el plan estructurado, y luego hacer un commit y obtener así ese estado seguro allí. Y luego paso a la implementación. Y si realmente quiero arreglar algo en mi sistema y volver a intentar, simplemente descartaré todo de nuevo a ese commit con un plan estructurado y seguiré adelante. Y así, lo que tengo para ti ahora mismo es una demostración en vivo. Soy esa persona loca que va a usar un coding assistant en medio de una presentación. No se vuelve más no determinista que esto, pero también trabajé muy duro para asegurarme de que fuera un proceso fluido. Así que aquí vamos.

Tengo este agente AI que construí usando mi marco de agente AI favorito, Pydantic AI. Es solo un agente simple, súper simple que construí para esta demo aquí que ayuda con la investigación web y la gestión de mi correo electrónico. Y así, imaginemos que pasé por un bucle PIV aquí para agregar la herramienta de búsqueda web a mi agente. Estoy usando Brave para la herramienta aquí. Y así, como dije, queremos mantener estas implementaciones de características, estos bucles PIV, muy granulares, como si solo estuviera agregando una sola herramienta a mi agente. No voy a intentar construir la infraestructura del agente, conectar el LLM, obtener el sistema prompt, obtener la herramienta de búsqueda web, y todas las herramientas de gmail todo en un solo bucle PIV. Como eso no es lo que estoy haciendo aquí, así que manteniéndolo realmente simple.

Como eso no es lo que estoy haciendo aquí, así que manteniéndolo realmente simple. Y así, como parte de mi sistema, una de las cosas que tengo es un comando de validación. Así que estoy aquí en Cloud Code ahora y tengo todos estos diferentes comandos configurados, que se llaman comandos slash en Cloud Code. Y así tengo bastantes comandos.

Hablaré más sobre algunos de los específicos en un momento, pero el que voy a usar ahora es mi comando de validación. Y así lo que esto va a hacer, te mostraré el proceso muy rápidamente. Lo tengo muy simple ahora mismo para propósitos de demostración. No hagas algo tan básico si realmente quieres una buena validación, pero ahora mismo todo lo que está haciendo es ejecutar la suite de pruebas unitarias. Así que solo va a ejecutar eso y hay 56 pruebas en total ahora mismo.

Y así, mientras hace eso en paralelo, obviamente no podemos simplemente esperar juntos a que termine, voy a hacer la prueba manual para el agente. Así que solo para propósitos de demostración, tengo una interfaz de línea de comandos súper simple aquí para hablar con el agente. Así que puedo decir, por ejemplo, ¿qué puedes hacer por mí? Esta es una buena prueba de humo que me gusta hacer para mis agentes para asegurarme de que todas las herramientas correctas estén realmente conectadas. Y ahí vamos. Puedo buscar en la web, resumir hallazgos de investigación y crear borradores de correos electrónicos profesionales. Bien, genial. De acuerdo, así que ahora intentemos algo ahora. Voy a darle una solicitud que realmente hará que haga una búsqueda en la web.

Y, oh, parece que tenemos un error. El objeto de contexto de ejecución no tiene el atributo brave API key. Bien, eso no se ve bien. Entonces, ¿por qué es eso? Bueno, primero que nada, echemos un vistazo a esto. Así que el agente no falló realmente. Esto es importante porque quiero cubrir la mejor validación en un momento aquí. Solo dice que actualmente no puedo realizar la búsqueda web. Así que definitivamente tenemos un problema en nuestra base de código.

Este bucle PIV no fue 100% exitoso. Pero luego volviendo a los registros aquí, así que en paralelo terminó el comando de validación y solo me está diciendo que obtuve marcas de verificación verdes en todos los aspectos. Todas las pruebas están pasando, nuestra evaluación de salud es buena. Pero claramente no lo es. Tenemos un problema. Nuestro código simplemente no está funcionando. Y aquí es donde llegamos a identificar nuestra brecha del sistema, pensando en qué parte de nuestro proceso aquí necesita ser mejor. Y así, saltando un poco más adelante, tal vez hice algo de planificación y algo de resolución de problemas con mi asistente de codificación, estoy pensando, bien, necesito actualizar mi comando de validación.

Obviamente, las pruebas unitarias no son suficientes aquí. Y sé que este es un ejemplo demasiado simple, pero esto es generalmente cómo se ve el proceso. Así que quiero arreglar mi validación, pero también quiero usar el asistente de codificación de AI para ayudarme a pensar en cómo lo haría. Y así tengo un prompt que ya he creado aquí que voy a pegar. Déjame ir y copiar esto justo aquí. Porque no quiero escribir esto desde cero con ustedes ahora mismo. Así que voy a enviar esto. Básicamente, solo estoy diciendo, como, probé esto manualmente. Aquí está el problema que obtuve. No puede obtener esa brave API key porque estás usando el contexto de la llamada de herramienta incorrectamente.

Y así, solo ayúdame a pensar en la palabra clave que me gusta usar aquí es meta razonamiento. Eso se conecta con el LLM. Como necesito hacer algo de auto-reflexión aquí y pensar en qué salió mal en el proceso. Como, ¿por qué mi validación no detectó esto realmente? Porque nuestro objetivo es que, si el asistente de codificación de AI tiene que cometer un error, al menos debería detectarlo al final del bucle PIV cuando está haciendo su propia validación. Y eso es lo que estoy haciendo aquí.

Y mientras esto avanza, volveré a mis diapositivas aquí y hablaré un poco más específicamente sobre los tipos de cosas que podemos actualizar. Y así, lo primero son nuestras reglas globales. Y así, todas las cosas que ya he mencionado, pero solo quiero profundizar un poco más en esto cuando pensamos en abordar una brecha del sistema. Y así, para las reglas globales solo tenemos que pensar para nosotros mismos, como, ¿es este problema un problema general que va a surgir como un patrón repetido sin importar lo que esté haciendo? No importa qué característica esté construyendo, qué error esté solucionando, ¿esto va a surgir? Y si la respuesta es sí, entonces probablemente deberías agregar algo o actualizar algo en tus reglas.

Y luego el siguiente punto es nuestro contexto bajo demanda. Y así, si este es un problema que solo va a surgir cuando estoy construyendo componentes de front-end, o solo surge cuando estoy agregando agentes a mis herramientas, solo para seguir usando los mismos ejemplos aquí, entonces debería actualizar algo en mi contexto bajo demanda. No necesito inflar mis reglas globales ahora mismo agregando eso. Es solo para un tipo de tarea específica. Y luego, por último, pero no menos importante, están nuestros comandos. Actualizar algo en nuestros comandos. Y esto realmente es el corazón de nuestro sistema, porque los prompts reutilizables son lo que define este flujo de trabajo que vamos a iterar y seguir usando una y otra vez. Y así los cuatro comandos principales que uso, sin importar en qué base de código esté trabajando, son preparación, planificación, implementación y validación.

Y lo que quiero decir con preparación es que ejecutaré esto en una nueva conversación con un asistente de codificación cuando esté trabajando en una base de código existente. Y es solo un conjunto de instrucciones sobre qué leer para ponerse al día rápidamente con la base de código. Así que ya sabes, preparándolo para la próxima implementación de características. Y así, lee el readme, asegúrate de leer los puntos de entrada principales de mi aplicación, ese tipo de cosas.

El comando de planificación es nuestro proceso para cómo investigamos esta nueva característica que estamos buscando. Y aquí es también donde pongo mi plantilla de plan estructurado. Así que aquí están las secciones que quiero que completes, como los criterios de éxito y la lista de tareas. El comando de implementación es donde desglosamos cómo manejar las tareas. Y luego tenemos el comando de validación, ese es el que estoy ejecutando. Eso es, verás en un poco el, bueno, en realidad, ya ejecutamos eso, así que ya viste el resultado de eso.

Así que cuando lo ejecutemos de nuevo, pero la validación es algo que tenemos como parte del plan estructurado. Pero es bueno sacar eso si queremos ejecutar nuestra validación ad hoc también, como estamos haciendo en la demostración en vivo aquí. Así que esas son las tres cosas que podemos mejorar. Y ahora mismo estoy mejorando el comando de validación. Así que volveré aquí. Y espero que en este punto, tengamos el resultado de nuestro asistente de codificación sobre lo que recomienda hacer. Muy bien. Así que déjame volver aquí arriba. Y bien, no voy a leer todo esto ahora mismo. Pero básicamente lo que está recomendando, y esto es genial, está recomendando ejecutar una prueba o crear un CLI de ejecución de pruebas.

esto es genial, está recomendando ejecutar una prueba o crear un test runner CLI. Así que crear una especie de arnés CLI para aprovechar realmente el agente, como enviar una solicitud al agente como una prueba más de extremo a extremo, lo que va a cubrir cosas que las pruebas unitarias obviamente no pueden, porque estamos simulando cosas como el contexto con la clave API de Brave, por eso la prueba unitaria no puede encontrar esto cuando una prueba de extremo a extremo sí puede.

Y así podría simplemente decirle que lo implemente ahora mismo, pero obviamente no tengo tiempo para hacer eso. Así que en su lugar voy a mostrarte una demostración basada en un ejemplo que generé con anticipación. Así que tengo el CLI creado aquí. Voy a copiarlo de mi carpeta de ejemplos y ponerlo en mi directorio raíz. Y luego voy a tomar mi nuevo comando de validación que también hice evolucionar para mí, que todavía tiene la prueba unitaria. Así que quiero agregar, como no estoy reemplazando la prueba unitaria, esas siguen siendo geniales. Pero luego quiero hacer la prueba de extremo a extremo también, describiendo cómo puedo usar este CLI para probar un par de consultas diferentes.

Y esto debería, con suerte, sacar a la luz el error para mí. Así que ahora voy a volver a Cloud Code, voy a salir de esto, y luego iniciarlo de nuevo. Y luego voy a ejecutar el comando de validación. Y así esta vez debería encontrar el problema y poder abordarlo, o tal vez simplemente me dirá como ya sabes aquí está lo que encontré quieres que lo arregle. Veremos, lo hace para mi prueba cualquiera de los dos solo porque mi comando es realmente breve en este momento, no soy súper específico.

Así que sí, lo último que quiero cubrir es esto. Esto realmente es el verdadero poder de la codificación agéntica sistemática. Porque primero, podemos aprovechar cada error en nuestro sistema. Así que ahora si funciona, eso es genial. Si no funciona, bueno, eso también es genial porque ahora finalmente tenemos una oportunidad de mejorar algo. Me da un poco de miedo cuando algo parece estar funcionando al 100% todo el tiempo, siento que en realidad hay un problema y simplemente no lo sé.

Y también, es agradable pensar en el hecho de que cuando mejoramos nuestro sistema, también está ayudando con todos los futuros proyectos. Sí, muchas de nuestras reglas y comandos y el contexto bajo demanda son específicos para nuestra base de código actual y deberías evolucionarlo para que sea muy opinado y específico, pero aún estamos tomando estos aprendizajes que ahora podemos aplicar a futuros proyectos. Como cómo hacemos que el coding assistant no escriba componentes de front end de 1000 líneas, por ejemplo.

Y luego también nuestro coding assistant simplemente se vuelve más inteligente con el tiempo. Eso siempre es una gran ventaja. Y por último, pero no menos importante, esto nos ayuda a construir confianza. Los coding assistants nunca van a ser perfectos, pero la habilidad más importante es simplemente saber hasta dónde puedes llevarlo. Y ese es un músculo que desarrollarás con el tiempo. Estarás seguro en tu sistema. Como sabrás dónde estás con tu sistema. Sabes cuán poderosos son los coding assistants en la actualidad.

tu sistema. Sabes cuán poderosos son los coding assistants en la actualidad. Y así entonces con eso, puedes evaluar como con esta nueva solicitud de función o este bug que tengo que abordar.

Como si voy a poder resolver esto en un solo piv-loop, o es algo que tengo que desglosar más. Y simplemente creces ese entendimiento con el tiempo de lo que puedes hacer, y luego a medida que evolucionas tu sistema, simplemente estiras eso más y más. Así que nunca es la expectativa que vas a poder hacer todo de una vez, pero sabes lo que puedes. Y así que voy a, solo para terminar la demo aquí, voy a volver a mi agente y ver qué tengo. Bien, así que en realidad no ha llegado al punto aún donde me ha dado el error, porque todavía está ejecutando la prueba.

Pero sí, llegaremos a eso en solo un segundo. Déjame poner esto en pantalla completa. Así que ejecutó la prueba unitaria, así que hizo esa parte de la validación. Ahora está llegando al punto donde está ejecutando el test harness. Así que está usando el CLI, y le dije que hiciera dos a tres pruebas, y así está terminando la tercera aquí, y luego informará el error.

del no-determinismo de usar un coding assistant en una presentación. O mi internet falló, quién sabe, pero probablemente habría recibido un error si ese fuera el caso. Así que sí, tal vez realmente lo cambie aquí y termine la presentación, y luego les muestre los resultados al final. Así que déjenme volver a mi última diapositiva aquí. Oh, también me desconectó. Eso es gracioso. Bien, ahí vamos. Genial, así que sí, última diapositiva aquí.

Tengo un par de acciones para ustedes. Así que la primera es simplemente aplicar el bucle PIV, incluso si nunca han hecho algo como esto antes. Solo piensen en cómo pueden planificar, luego implementar, y luego validar, y crear su biblioteca de comandos para ayudarles a hacer esto. No estoy escribiendo todos mis prompts manualmente para cómo quiero investigar y planificar y cosas así.

Siempre lo hago a través de comandos, y luego a través de esto probablemente encontrarán un error, pero esa es su primera oportunidad para abordar una brecha del sistema, así que les animo a hacer eso. Y también dejen que su coding assistant les ayude. No tienen que hacerlo ustedes mismos. Quieren aprovechar al máximo el coding assistant tanto como puedan, para delegar tanto código como sea posible, y para ayudarles a pensar en cómo solucionar estos problemas cuando surjan. Y con eso, volveré a la diapositiva en un segundo. Espero que ya esté hecho para que al menos pueda mostrarles que encontró el error. No necesito abordarlo ni nada ahora mismo. Bien, encontró un problema crítico. Bien, pero díganme qué es. Bien, aquí vamos.

Así que, bien, finalmente. Muy bien, terminaré la demostración aquí. No necesito obviamente encontrar el error y volver a intentarlo, pero esto es lo que hay aquí. El código está accediendo incorrectamente a la clave API de Brave. Debería ser context.dependencies.braveapikey en lugar de no incluir las dependencias. Y ahí vamos. De hecho, fue y realizó la corrección también, y ahora está haciendo ese ciclo iterativo del que estaba hablando donde está ejecutando nuevamente el CLI test harness para asegurarse de que ahora la búsqueda web sea exitosa.

Así que, perfecto. Y volveré a la diapositiva aquí para concluir. Muy bien, así que sí, lo último que quiero decir es que si estás interesado en profundizar más en esto y realmente quieres aprender cómo construir tu propio sistema para codificación de IA y crearlo de una manera que pueda auto-evolucionar, tengo un código QR aquí mismo. Estoy trabajando en un nuevo curso de codificación agentic en mi comunidad Dynamis, y es simplemente una cantidad increíble de esfuerzo que he estado dedicando a construir esto para ti. Así que sí, escanea el código QR si estás interesado. Espero verte allí. Me divertí mucho con esto, y gracias a todos por estar aquí.

Tenemos un par de preguntas diferentes en el tablero, pero una de ellas es que mencionaste el bucle PIV. ¿Has intentado usar el desarrollo dirigido por pruebas para ello? Planifica primero, desarrolla las validaciones y luego implementa las soluciones, o implementa una vez que las soluciones sean sólidas. Sí, esa es una muy buena pregunta. Así que yo no he hecho desarrollo dirigido por pruebas mucho en el pasado. Tengo respeto por ello, simplemente no es lo mío. Lo he intentado con un bucle PIV antes, y el bucle PIV es flexible. Puede funcionar sin importar cómo quieras trabajar. Así que si haces desarrollo dirigido por pruebas, eso es solo una parte de tu plan estructural. Como, tu primera tarea en la lista de tareas para tu plan estructural es escribir las pruebas, y luego ir y crear el código y probar contra eso. Y así definitivamente puedes hacer eso. Simplemente invierte el orden de las cosas durante la implementación en sí, y cómo delineas la implementación en el plan estructural, pero el mismo enfoque y la forma en que evolucionas el sistema y todo es exactamente la misma.

Perfecto, y luego creo que tenemos tiempo para una más. ¿Tienes tus comandos slash compartidos en algún lugar? Sí, los tengo. Así que, en el curso de codificación agentic de Dynamis que mencioné, oh, me desconectó de nuevo. Eso es desafortunado. Bueno, sí, en el código QR que tenía allí para el curso, comparto todos los comandos. Tengo una biblioteca de comandos completa, y también, hago mucho con código abierto y Github, y así tengo muchos de los comandos allí también. Y así, si vas a mi Github, hay un repositorio en particular llamado el contexto engineering intro, y ahí es donde tengo muchos comandos, así como una estrategia más opinada para la ingeniería de contexto llamada el marco PRP que implementa el bucle PIV de una manera muy inteligente, pero más opinada. Ese es otro conjunto de comandos que tengo disponibles en ese repositorio.

Genial. ¿Puedes compartir el nombre de Github solo para cualquiera que pueda habérselo perdido? Por supuesto, sí. Es coleam00. C-O-L-E-A-M-0-0. ¡Perfecto! Muchas gracias. Demos a Cole otro aplauso. Gracias, chicos.