Todo Lo Que Sabía Sobre Programación Con IA Estaba Equivocado

AAI LABS
Computing/SoftwareInternet Technology

Transcript

00:00:00Ya conoces estos frameworks de codificación con IA como Beemad,
00:00:03Speckit y otros,
00:00:04pero estos no son los únicos.
00:00:06Hay cientos de personas experimentando y lanzando sus propios flujos de trabajo,
00:00:09pero cuando los pruebas,
00:00:11notarás que a menudo no cumplen con lo que prometen.
00:00:13No es porque sus métodos sean malos,
00:00:15es porque no se ajustan a tu caso de uso específico.
00:00:18Cuando construimos aplicaciones,
00:00:19la mayoría del tiempo creamos nuestros propios flujos de trabajo en lugar de depender de los predefinidos.
00:00:23Esto se debe a que los flujos de trabajo deben construirse en torno a tu caso de uso específico y solo funcionan si se alinean con el proyecto que estás intentando construir.
00:00:30Entonces,
00:00:30¿cómo construyes un flujo de trabajo para tu propio proceso?
00:00:32Para eso, necesitas conocer ciertos principios.
00:00:34Estos son los principios que cada framework utiliza de una forma u otra.
00:00:38Antes de discutir los principios principales,
00:00:40es esencial que sepas qué hay dentro de la ventana de contexto de estas herramientas de IA.
00:00:44Es realmente importante,
00:00:45ya que gestionar el contexto es básicamente lo que hacen estos frameworks.
00:00:48La ventana de contexto es básicamente la cantidad de información que el modelo puede recordar a la vez.
00:00:53Cualquier cosa que salga de la ventana de contexto del modelo sale de su memoria de trabajo,
00:00:57y no tiene forma de recordarlo.
00:00:59Los modelos tienen una ventana de contexto limitada.
00:01:00Por ejemplo,
00:01:01los modelos de Anthropic tienen una ventana de contexto de 200k tokens,
00:01:04y los modelos Gemini tienen 1 millón.
00:01:06Aunque estos números pueden parecer realmente grandes en términos de los mensajes que envías,
00:01:10en realidad no son tan enormes,
00:01:11porque en estas herramientas de IA,
00:01:13la ventana de contexto no solo consiste en tu prompt del sistema y mensajes de usuario,
00:01:17sino que también incluye muchas otras cosas como tus mensajes anteriores,
00:01:20archivos de memoria,
00:01:21herramientas,
00:01:22llamadas MCP y demás.
00:01:23Necesitas aprender a aprovechar al máximo este espacio de trabajo limitado,
00:01:26para que cuando construyas tus flujos de trabajo,
00:01:28el modelo haga exactamente lo que quieres que haga.
00:01:30Usaré Claude Code como mi herramienta principal de codificación a lo largo del video,
00:01:34pero puedes construir tu flujo de trabajo con cualquier plataforma,
00:01:36ya que todas tienen las herramientas necesarias para estos principios.
00:01:39El principio más importante y la clave para cualquier diseño de flujo de trabajo es la revelación progresiva.
00:01:44Eso significa revelar al LLM solo lo que importa,
00:01:46y mantener la atención del modelo enfocada en lo que realmente se necesita ahora,
00:01:50en lugar de llenar la ventana de contexto con todo lo que podría necesitar en el futuro.
00:01:54Ahora,
00:01:55los modelos más avanzados como Sonnet 4.5 tienen una función de edición de contexto integrada,
00:02:00donde pueden entender qué es ruido e intentar filtrarlo por sí mismos,
00:02:04y usan comandos grep para reducir lo que quieres.
00:02:07Pero eso solo no es suficiente.
00:02:08Cuando damos instrucciones vagas,
00:02:10incluso estos modelos más nuevos cargan muchas cosas que no son necesarias y contaminan la ventana.
00:02:14En lugar de pedirle a Claude que arregle el error en tu backend,
00:02:18es mejor pedirle que revise los endpoints uno por uno,
00:02:20en lugar de pedirle que arregle todo de una vez.
00:02:23La función de habilidades en Claude ahora es de código abierto y todas las herramientas pueden usarla.
00:02:27Las habilidades son prácticamente la encarnación de la revelación progresiva.
00:02:29Su descripción proporciona la información justa para que tu plataforma de codificación con IA sepa cuándo debe usarse cada habilidad sin cargar todo en el contexto.
00:02:38Un gran error que comete la gente es usar MCPs para todo.
00:02:41Solo deberías usar MCPs cuando se requieran datos externos y usar habilidades para todo lo demás.
00:02:46El segundo principio igualmente importante es que la información que no se necesita ahora mismo no debería estar en la ventana de contexto.
00:02:52Para lograr esto,
00:02:53las herramientas usan toma de notas estructurada.
00:02:55Y podemos usar esto a nuestro favor proporcionando a tu herramienta de IA archivos externos que pueda usar para documentar cualquier decisión,
00:03:01problema o deuda técnica.
00:03:03Este enfoque permite que tu agente mantenga un contexto crítico que de otra forma se perdería al construir algo realmente complejo.
00:03:09Estas herramientas también tienen una función de compactación para gestionar la ventana de contexto.
00:03:13Y cuando el contexto se reinicia,
00:03:15no tienes que depender únicamente del resumen de compactación.
00:03:17Por ejemplo,
00:03:18tu agente puede usar estas notas para obtener contexto sobre lo que ya se ha hecho y lo que aún falta por hacer.
00:03:23Este enfoque es particularmente útil para tareas de horizonte largo,
00:03:26que son inherentemente complejas.
00:03:28Quizás estés familiarizado con el agent.md.
00:03:30Es un archivo de contexto estándar que todos los agentes leen antes de iniciar la sesión.
00:03:34Algunos agentes no siguen esto y tienen el suyo propio,
00:03:37como el claud.md,
00:03:38y los uso para guiar al agente sobre cómo están estructurados los archivos externos y qué escribir en cada uno de ellos.
00:03:44A veces estos agentes se detienen aleatoriamente en medio de una tarea de larga duración.
00:03:47Muchas veces esto sucede porque el contexto ha superado el 70% de su límite.
00:03:52Aquí es donde entra el concepto de presupuesto de atención.
00:03:55Tu ventana de contexto es a lo que el modelo presta atención mientras genera la salida.
00:03:59Cuando supera el 70%,
00:04:00el modelo tiene que concentrarse más y hay una mayor probabilidad de alucinaciones.
00:04:04En términos de agentes de IA,
00:04:06les impide usar sus herramientas de manera efectiva y a menudo simplemente eligen ignorarlas.
00:04:10Para resolver esto,
00:04:11hay varias herramientas integradas que puedes usar.
00:04:14Como ya sabes,
00:04:14la compactación permite que el modelo comience de nuevo con un resumen adecuado de lo que ha sucedido como prompt inicial y una ventana de contexto reducida.
00:04:21Así que en lugar de dejarlo llenar hasta el 90% y activar la función de auto-compactación,
00:04:25intenta vigilar la ventana de contexto y hazlo tú mismo.
00:04:28Si estás experimentando,
00:04:29usa el retroceso integrado de Claude para que puedas eliminar las partes innecesarias en lugar de continuarlas y pedirle cambios a Claude.
00:04:36También deberías limpiar o iniciar una nueva ventana de contexto para cualquier nueva tarea para que el contexto anterior no ralentice el modelo.
00:04:42Otra cosa que deriva del principio de revelación progresiva es la capacidad de estos agentes para ejecutar tareas en segundo plano sin contaminar la ventana de contexto principal.
00:04:51Los subagentes trabajan en su propia ventana de contexto aislada y solo reportan la salida al agente principal.
00:04:57Esto es particularmente útil cuando trabajas en tareas que están aisladas entre sí porque tu ventana de contexto principal está protegida de ser saturada con las llamadas de herramientas y búsquedas que hace el subagente,
00:05:06asegurando que la información permanezca en su zona de trabajo dedicada.
00:05:10Como estos agentes se ejecutan en segundo plano,
00:05:12puedes seguir interactuando con tu agente principal y dejarlo trabajar en algo que realmente requiera tu atención.
00:05:17Siempre que quiero que se investigue algo,
00:05:19como las reglas de un nuevo framework con el que estoy trabajando,
00:05:22simplemente uso estos subagentes.
00:05:23De esta manera,
00:05:24sus llamadas de herramientas y búsquedas están aisladas y simplemente devuelven la respuesta al agente principal.
00:05:29Si entiendes el principio de la toma de notas,
00:05:31también debes saber qué formato de archivo usar para qué tarea.
00:05:34Como estos archivos tienen diferentes formatos,
00:05:36afectan el conteo de tokens y,
00:05:38por lo tanto,
00:05:38la eficiencia de tu flujo de trabajo.
00:05:40YAML es el más eficiente en tokens,
00:05:41así que lo uso principalmente para esquemas de bases de datos,
00:05:44configuraciones de seguridad y detalles de API.
00:05:46Su indentación ayuda a los modelos a estructurar la información correctamente.
00:05:49Markdown es mejor para documentación como tu claud.md porque los niveles de encabezado facilitan que el modelo navegue entre secciones.
00:05:56XML está específicamente optimizado para modelos de Claude.
00:05:59Anthropic afirma que sus modelos están ajustados para reconocer estas etiquetas como contenedores y separadores,
00:06:05lo cual es útil cuando tienes secciones distintas como restricciones,
00:06:08resúmenes o detalles visuales.
00:06:10Otros modelos generalmente prefieren Markdown y YAML sobre XML.
00:06:13Y por último, JSON.
00:06:14Es el menos eficiente en tokens debido a todas las llaves y comillas adicionales,
00:06:17así que solo lo uso para cosas pequeñas como estados de tareas y realmente no recomiendo usarlo en la mayoría de los casos.
00:06:23Git es una de las cosas más básicas que te enseñan cuando empiezas a programar.
00:06:26Hemos visto otra tendencia con estos flujos de trabajo de contexto en la que la gente realmente usa el historial de commits de git como recordatorio para el modelo del progreso que se ha hecho,
00:06:35ya sea en todo el proyecto o en una sola tarea.
00:06:37Incluso si no quieres usarlo para almacenar el progreso,
00:06:40generalmente deberías usar estos flujos de trabajo de ingeniería de contexto en un repositorio inicializado con git.
00:06:44Tener un flujo de trabajo de ingeniería de contexto significa que no permites que el modelo haga todo a la vez,
00:06:49sino que actúe paso a paso según lo planificado.
00:06:51Si en alguna etapa encuentras un problema,
00:06:54git te permite controlar a qué versión revertir y ayuda a evaluar qué cambio está causando problemas.
00:06:59La gente también ha implementado paralelismo con git worktrees.
00:07:02También he mostrado varios flujos de trabajo donde los sub-agentes trabajan en worktrees dedicados para trabajo paralelo.
00:07:07Cualquiera que sea el flujo de trabajo que termines creando,
00:07:09siempre habrá casos en los que termines repitiendo instrucciones para procedimientos comunes.
00:07:13Un buen ejemplo es cómo le pides a las herramientas de IA que hagan commits de git o actualicen tu documentación.
00:07:18En casi todas estas herramientas de IA,
00:07:20hay formas de reutilizar tus prompts más repetidos.
00:07:22A menudo uso custom/commands en mis propios proyectos porque básicamente le dan a Claude una guía reutilizable.
00:07:28A menudo uso un comando catchup que contiene instrucciones sobre cómo estructuro la memoria fuera de la ventana de contexto,
00:07:34para que Claude sepa cómo ponerse al día con el proyecto en lugar de leer cada archivo.
00:07:38También son buenos para hacer cumplir la estructura.
00:07:40Para que mis commits y documentación sigan un formato definido,
00:07:43uso un commit/command que sigue una estructura específica de cómo debe escribir los mensajes de commit y qué verificaciones pre-commit debe hacer antes de confirmar.
00:07:51De esta manera los /commands mantienen todo estandarizado,
00:07:53y no tengo que instruir a Claude una y otra vez para realizar tareas de la forma que prefiero.
00:07:58Como sabes,
00:07:58los MCPs deben usarse siempre que se requieran datos externos.
00:08:01Jira es el software de gestión de equipos más utilizado.
00:08:04Si quieres obtener información de los tickets,
00:08:06puedes usar el MCP de Jira para que pueda acceder a los tickets directamente y comenzar a implementar cambios.
00:08:11De manera similar,
00:08:12uso el MCP de Figma para proporcionarle a Claude el código con la guía de estilo de la aplicación,
00:08:16que luego usa para construir el diseño.
00:08:18Para tareas donde las capacidades integradas del modelo no son suficientes,
00:08:21los MCPs son esenciales para interactuar con fuentes externas de manera eficiente.
00:08:25Puedes incluir estos MCPs directamente en tus /commands para que se conviertan en parte de todo tu flujo de trabajo.
00:08:31Eso nos lleva al final de este video.
00:08:32Si te gustaría apoyar el canal y ayudarnos a seguir haciendo videos como este,
00:08:36puedes hacerlo usando el botón de super thanks abajo.
00:08:39Como siempre, gracias por ver y nos vemos en el próximo.

Key Takeaway

Los frameworks de IA no funcionan universalmente porque los flujos de trabajo efectivos deben construirse en torno a casos de uso específicos, aplicando principios de revelación progresiva y gestión inteligente de la ventana de contexto.

Highlights

La revelación progresiva es el principio más importante: mostrar al modelo solo la información necesaria en cada momento, evitando saturar la ventana de contexto

La ventana de contexto incluye no solo prompts y mensajes, sino también archivos de memoria, herramientas y llamadas MCP, por lo que se llena rápidamente

Usar habilidades (skills) en lugar de MCPs siempre que sea posible; los MCPs solo deben usarse cuando se requieran datos externos

La toma de notas estructurada permite documentar decisiones y deuda técnica en archivos externos, preservando información crítica para tareas complejas

El presupuesto de atención se agota cuando el contexto supera el 70%, causando alucinaciones y que el modelo ignore herramientas disponibles

Los subagentes trabajan en ventanas de contexto aisladas, protegiendo la ventana principal de saturarse con llamadas de herramientas innecesarias

YAML es el formato más eficiente en tokens para esquemas y configuraciones, mientras que XML está optimizado específicamente para modelos de Claude

Timeline

Introducción: El problema con los frameworks predefinidos

El video presenta frameworks de codificación con IA como Beemad y Speckit, explicando que aunque existen cientos de flujos de trabajo disponibles, frecuentemente no cumplen sus promesas. El problema fundamental no radica en la calidad de los métodos, sino en que no se ajustan a casos de uso específicos de cada usuario. Al construir aplicaciones, es necesario crear flujos de trabajo personalizados en lugar de depender de los predefinidos, ya que deben alinearse con el proyecto específico que se está desarrollando. Para construir estos flujos de trabajo personalizados, es esencial conocer ciertos principios fundamentales que todos los frameworks utilizan de una forma u otra.

Comprendiendo la ventana de contexto

Se explica que la ventana de contexto es la cantidad de información que el modelo puede recordar simultáneamente, y gestionar este contexto es básicamente lo que hacen los frameworks. Los modelos tienen ventanas limitadas: Anthropic ofrece 200k tokens y Gemini 1 millón. Aunque estos números parecen grandes, en realidad no lo son tanto porque la ventana no solo incluye el prompt del sistema y mensajes del usuario, sino también mensajes anteriores, archivos de memoria, herramientas y llamadas MCP. Cualquier información fuera de esta ventana sale de la memoria de trabajo del modelo sin posibilidad de recuperación. Es crucial aprender a aprovechar al máximo este espacio de trabajo limitado para que el modelo haga exactamente lo que se necesita al construir flujos de trabajo personalizados.

Principio de revelación progresiva

La revelación progresiva es el principio más importante en el diseño de flujos de trabajo, consistiendo en revelar al modelo solo lo que importa y mantener su atención enfocada en lo necesario ahora, no en todo lo que podría necesitar en el futuro. Aunque modelos avanzados como Sonnet 4.5 tienen edición de contexto integrada y usan comandos grep para filtrar información, esto solo no es suficiente. Cuando se dan instrucciones vagas, incluso estos modelos cargan información innecesaria que contamina la ventana. En lugar de pedir arreglar un error general en el backend, es mejor solicitar revisar endpoints uno por uno. Las habilidades (skills) en Claude son de código abierto y representan la encarnación de la revelación progresiva, proporcionando información justa para que la plataforma sepa cuándo usar cada habilidad sin cargar todo en el contexto.

Uso correcto de MCPs vs habilidades

Se advierte sobre un error común: usar MCPs (Model Context Protocol) para todo, cuando en realidad solo deberían usarse cuando se requieran datos externos, reservando las habilidades para todo lo demás. El segundo principio importante establece que la información que no se necesita inmediatamente no debería estar en la ventana de contexto. Para lograr esto, las herramientas utilizan toma de notas estructurada, permitiendo proporcionar archivos externos donde el agente puede documentar decisiones, problemas o deuda técnica. Este enfoque es crucial para mantener contexto crítico que de otra forma se perdería al construir proyectos complejos, especialmente porque permite que el agente recupere información sobre lo que se ha hecho y lo que falta por hacer.

Gestión de contexto con archivos externos y compactación

Se introduce el concepto de archivos de contexto estándar como agent.md o claud.md, que los agentes leen antes de iniciar sesiones para entender cómo están estructurados los archivos externos y qué escribir en cada uno. Las herramientas tienen funciones de compactación para gestionar la ventana de contexto, y cuando el contexto se reinicia, el agente puede usar estas notas para obtener contexto en lugar de depender únicamente del resumen de compactación. Este enfoque es particularmente útil para tareas de horizonte largo que son inherentemente complejas. Un problema común es que los agentes se detienen aleatoriamente en medio de tareas largas, lo cual frecuentemente ocurre porque el contexto ha superado el 70% de su límite, introduciendo el concepto de presupuesto de atención.

Presupuesto de atención y optimización del contexto

Cuando el contexto supera el 70% de su capacidad, el modelo debe concentrarse más y aumenta la probabilidad de alucinaciones, impidiendo que los agentes usen herramientas efectivamente y optando por ignorarlas. Para resolver esto, existen varias herramientas integradas disponibles. La compactación permite que el modelo comience de nuevo con un resumen adecuado como prompt inicial y una ventana reducida, pero en lugar de dejar que se llene hasta el 90% y active la auto-compactación, es mejor vigilar la ventana y hacerlo manualmente. Al experimentar, se recomienda usar el retroceso integrado de Claude para eliminar partes innecesarias en lugar de continuar y pedir cambios. También es importante limpiar o iniciar nueva ventana de contexto para cada tarea nueva, evitando que el contexto anterior ralentice el modelo.

Subagentes y trabajo en segundo plano

Los subagentes derivan del principio de revelación progresiva y pueden ejecutar tareas en segundo plano sin contaminar la ventana de contexto principal. Trabajan en su propia ventana de contexto aislada y solo reportan la salida al agente principal, lo cual es útil para tareas aisladas entre sí. La ventana de contexto principal está protegida de saturarse con llamadas de herramientas y búsquedas que hace el subagente, asegurando que la información permanezca en su zona de trabajo dedicada. Como estos agentes se ejecutan en segundo plano, se puede continuar interactuando con el agente principal mientras trabaja en algo que requiera atención. El presentador menciona usar subagentes cuando necesita investigar algo, como reglas de un nuevo framework, de manera que sus llamadas y búsquedas quedan aisladas y solo devuelven la respuesta al agente principal.

Optimización de formatos de archivo

Diferentes formatos de archivo afectan el conteo de tokens y la eficiencia del flujo de trabajo. YAML es el más eficiente en tokens, usado principalmente para esquemas de bases de datos, configuraciones de seguridad y detalles de API, ya que su indentación ayuda a los modelos a estructurar información correctamente. Markdown es mejor para documentación como claud.md porque los niveles de encabezado facilitan la navegación entre secciones. XML está específicamente optimizado para modelos de Claude, ya que Anthropic afirma que sus modelos están ajustados para reconocer etiquetas como contenedores y separadores, útil para secciones distintas como restricciones, resúmenes o detalles visuales. Otros modelos generalmente prefieren Markdown y YAML sobre XML, mientras que JSON es el menos eficiente debido a llaves y comillas adicionales, recomendándose solo para cosas pequeñas como estados de tareas.

Git como herramienta de gestión de progreso

Git, una de las herramientas básicas en programación, se ha vuelto tendencia en flujos de trabajo de contexto donde el historial de commits sirve como recordatorio para el modelo del progreso realizado en el proyecto o en tareas individuales. Incluso sin usarlo para almacenar progreso, generalmente se deberían usar flujos de trabajo de ingeniería de contexto en repositorios inicializados con git. Tener un flujo de trabajo de ingeniería de contexto significa no permitir que el modelo haga todo a la vez, sino actuar paso a paso según lo planificado. Si se encuentra un problema en alguna etapa, git permite controlar a qué versión revertir y ayuda a evaluar qué cambio está causando problemas. Además, se ha implementado paralelismo con git worktrees, donde sub-agentes trabajan en worktrees dedicados para trabajo paralelo.

Comandos personalizados y reutilización de prompts

En cualquier flujo de trabajo creado, siempre habrá casos donde se repiten instrucciones para procedimientos comunes, como hacer commits de git o actualizar documentación. Casi todas las herramientas de IA ofrecen formas de reutilizar prompts más repetidos mediante comandos personalizados (custom/commands) que funcionan como guías reutilizables. El presentador usa un comando 'catchup' que contiene instrucciones sobre cómo estructura la memoria fuera de la ventana de contexto, permitiendo que Claude se ponga al día con el proyecto sin leer cada archivo. También son útiles para hacer cumplir estructura: un comando 'commit' asegura que commits y documentación sigan un formato definido, especificando cómo escribir mensajes de commit y qué verificaciones pre-commit hacer antes de confirmar. De esta manera, los comandos mantienen todo estandarizado sin tener que instruir repetidamente a Claude sobre cómo realizar tareas preferidas.

MCPs para datos externos y conclusión

Los MCPs deben usarse siempre que se requieran datos externos de fuentes como Jira, el software de gestión de equipos más utilizado. El MCP de Jira permite acceder a tickets directamente para implementar cambios, mientras que el MCP de Figma proporciona a Claude código con la guía de estilo de la aplicación para construir el diseño. Para tareas donde las capacidades integradas del modelo no son suficientes, los MCPs son esenciales para interactuar con fuentes externas de manera eficiente. Estos MCPs pueden incluirse directamente en comandos personalizados para que se conviertan en parte del flujo de trabajo completo. El video concluye invitando a apoyar el canal mediante el botón de super thanks y agradeciendo a los espectadores por ver el contenido.

Community Posts

View all posts