Big Projects Always Fail... Anthropic Is Fixing That

EspañolEnglishBahasa Indonesia한국어Português
AAI LABS
Computing/SoftwareSmall Business/StartupsInternet Technology

Transcript

00:00:00Hoy en día, lanzar proyectos pequeños se ha vuelto muy fácil, pero los agentes comienzan a fallar en el momento
00:00:04en que la base de código crece y adquiere múltiples dependencias. El problema empeora aún más si
00:00:09trabajas con lenguajes poco convencionales, donde los errores y problemas se vuelven aún más difíciles de rastrear.
00:00:14Lo que la gente pasa por alto es que debes tomar las medidas adecuadas antes de poner a los agentes a trabajar en bases
00:00:19de código grandes, y esto es exactamente de lo que habla Anthropic aquí. Ellos explican cómo manejar
00:00:23proyectos cuando escalan. Fue realmente revelador porque son cosas que nosotros mismos hemos estado
00:00:28usando en nuestros propios proyectos y hemos encontrado bastante útiles. Antes de entrar en detalle sobre cómo configurar
00:00:33un proyecto a gran escala, entendamos primero cómo navegan los agentes por el
00:00:38código en general. Hay dos formas en que lo hacen. La primera es basada en RAG. Funciona incrustando
00:00:43toda la base de código y recuperando los fragmentos relevantes en el momento de la consulta. Según tu consulta, ejecuta
00:00:48una búsqueda semántica que hace coincidir tu consulta con el código en su base de datos. A partir de las coincidencias de similitud,
00:00:53carga ese contexto específico para que el modelo lo analice y trabaje a partir de ahí. Esto podría funcionar para
00:00:58aplicaciones a pequeña escala, pero no se sostiene en las grandes. Esto se debe a que hay una base de datos central
00:01:03que mantiene los datos, y si hay muchos archivos en la base de datos, la coincidencia semántica
00:01:08puede ser problemática. Esta es la razón por la que los agentes de codificación alucinan módulos que ya no existen.
00:01:14Precisamente debido a estos problemas, el enfoque basado en RAG ha sido completamente reemplazado. El otro
00:01:18tipo es la navegación basada en el sistema de archivos, que es lo que Claude Code y la mayoría de los demás agentes usan ahora. Esto
00:01:24es similar a cómo navegan realmente los desarrolladores de software. El agente utiliza herramientas de bash, encuentra archivos
00:01:29con el comando ls, luego usa grep y reduce la búsqueda hasta el fragmento de código exacto que necesita y carga eso
00:01:34en el contexto. Las herramientas de bash funcionan porque no contaminan la ventana de contexto con fragmentos
00:01:39innecesarios. Así que este modo soluciona todas las formas en que fallaban los sistemas basados en RAG, y casi todos
00:01:44los agentes de codificación ahora navegan de esta manera. Lo importante aquí es que, sin importar cómo mejoren los modelos
00:01:49por sí mismos, el modelo por sí solo no determina qué tan bueno será el código que puedes producir.
00:01:54Algo aún más importante cuando se trata de sistemas funcionales es qué armazón (harness) utilizas
00:01:59para programar. Así que, sea cual sea la herramienta que uses, ya sea Claude Code, Codex o Gemini CLI, el resultado que
00:02:05obtienes no depende únicamente de sus potentes modelos. También depende del armazón que combines con las
00:02:10capacidades del modelo. Si el armazón es débil y el modelo es fuerte, no tiene sentido que el modelo
00:02:15sea fuerte por sí solo. Ahora, sabemos que agentes como Claude Code y Codex tienen armazones inherentemente fuertes,
00:02:19pero esto no significa que debas confiar solo en ellos. Necesitas configurar un armazón
00:02:24adaptado directamente a tu proyecto para que se ajuste mejor a él. También existen armazones de código abierto
00:02:29como superpowers, y puedes usar cualquiera de ellos cuando estás construyendo algo, pero cuando estás
00:02:33desarrollando un proyecto a gran escala, estos armazones podrían no ser suficientes y necesitarás configurar
00:02:38el tuyo de todos modos. Cada armazón de agente que construyes por tu cuenta o extraes de chats compartidos contiene
00:02:42cinco piezas centradas en cómo se configuran ambientalmente los trabajos y bucles de agentes de Claude.
00:02:47Repasaremos cada una. La primera pieza en el armazón del agente es el archivo Claude.md, que se carga
00:02:53al inicio de la sesión y permanece en la memoria durante toda ella. Este archivo es realmente
00:02:57importante porque le da a Claude la base de conocimientos para la base de código. Ya hemos hecho un video
00:03:02separado sobre cómo escribir y estructurar un Claude.md adecuado, que puedes ver en el canal.
00:03:07Cuando tu base de código crece, Claude.md se vuelve fundamental. Si no le dedicas tiempo,
00:03:12tu proyecto está destinado a fallar a escala. Este archivo es para convenciones del proyecto, conocimientos de la base de código
00:03:17y los pros y contras que se aplican a toda la base de código, no solo a un aspecto. Esto
00:03:22podría estar bien si tu base de código es pequeña, pero se convierte en un problema en el momento en que escalas a múltiples
00:03:26arquitecturas. Así que meter todos los aspectos del código en un solo archivo es altamente ineficiente. Distrae
00:03:32al agente con información que no necesita en el momento. Es por eso que el Claude.md debe mantenerse corto,
00:03:37idealmente alrededor de 300 líneas, y si estás ejecutando un monorepo con múltiples áreas, cada subdirectorio
00:03:43debería tener su propio Claude.md siguiendo las mismas reglas. El agente lo carga progresivamente cuando trabaja
00:03:48en ese directorio, así que en lugar de extraer todo del archivo raíz, recibe instrucciones más enfocadas
00:03:53de los archivos del subdirectorio. Este archivo no es algo que escribas una vez y en lo que confíes para siempre. Necesitamos
00:03:58mantenerlo activamente, no solo a medida que evoluciona el proyecto, sino también a medida que evoluciona la inteligencia del modelo.
00:04:04Los principios aplicables a Sonnet 4.5 definitivamente no se aplicarán a Opus. Los modelos más nuevos
00:04:09están entrenados para superar patrones que fallaban en instrucciones anteriores. Así que dar las mismas
00:04:14instrucciones a cada modelo solo desperdicia tokens. Pero antes de seguir adelante, unas palabras de
00:04:19nuestro patrocinador, CleanMyMac. Si trabajas con herramientas de IA como nosotros, tu Mac acumula silenciosamente basura, compilaciones antiguas,
00:04:26caché, descargas rotas, y no te das cuenta hasta que empieza a ir lento. Ejecuto CleanMyMac cada semana y
00:04:31libera más de 15 GB en un solo escaneo. Eso es todo, con un clic mi Mac vuelve a estar como nueva. CleanMyMac
00:04:37es creado por MacPaw, cuenta con la certificación de Apple y cuenta con la confianza de más de 29 millones de personas durante 17 años. La función de limpieza
00:04:42elimina más de 20 tipos de basura para que tu sistema se mantenga rápido sin tener que vigilarlo. SpaceLens mapea
00:04:48tu disco visualmente para que sepas qué ocupa espacio. Incluso escanea tu iCloud, Google Drive y
00:04:53Dropbox localmente en busca de archivos no sincronizados que desperdician almacenamiento en la nube. Y detecta el 99% del malware conocido a través de
00:04:59Moonlock, para que tu Mac se mantenga limpia y segura. Tu Mac debería seguirte el ritmo, no al revés.
00:05:03Usa el código AI Labs para obtener un 20% de descuento y prueba CleanMyMac gratis durante siete días. Ahora, los hooks son
00:05:09otra cosa importante que ayuda al trabajar con estas grandes bases de código. Son básicamente
00:05:14scripts que permiten al agente realizar acciones específicas según ciertas condiciones. Hay muchos tipos
00:05:19de hooks que puedes configurar, generalmente escritos como scripts de shell que controlan el comportamiento del agente. Por
00:05:23ejemplo, puedes configurar un hook de inicio de sesión que cargue la información que deseas al inicio
00:05:28de cada sesión, como qué archivos debería cargar Claude para obtener contexto. También puedes usar un hook con código de salida
00:05:33también, y enviar el mensaje de error de vuelta a Claude para que pueda iterar sobre eso. Los hooks de pre-uso de herramientas son otro
00:05:38tipo. Cada vez que el agente usa la herramienta que hayas configurado para el hook, ejecuta tus comandos.
00:05:43Puedes usarlo para evitar que Claude edite archivos que no quieres que toque. Pero uno de los más
00:05:48importantes es el hook de detención, que se ejecuta después de que finaliza una sesión. Esto empuja a Claude a reflexionar sobre
00:05:53lo que se ha hecho hasta ahora. A partir de eso, puede actualizar el Claude.md con los aprendizajes de la sesión
00:05:58para que los mismos problemas no vuelvan a ocurrir. También puedes configurar hooks para linting, ejecutar pruebas,
00:06:03y muchos otros propósitos. Todo esto, unido, ayuda mucho con las bases de código a gran escala.
00:06:08Los hooks obligan al agente a hacer cosas con las que debe ser cuidadoso, donde las instrucciones en Claude.md
00:06:13por sí solas pueden no ser suficientes. Las instrucciones en Claude.md pueden difuminarse en el lapso de atención del agente debido
00:06:19a demasiadas cosas en las que enfocarse, pero los hooks realmente fuerzan a Claude a actuar. La tercera pieza en el
00:06:23flujo de trabajo son las habilidades (skills). Es un conjunto de archivos skills.md y otros archivos agrupados que se cargan bajo demanda en lugar
00:06:29de estar presentes en cada sesión y bloquearla innecesariamente. Las habilidades son importantes porque
00:06:34utilizan la divulgación progresiva y están adaptadas para realizar una tarea especializada específica necesaria para el
00:06:40flujo de trabajo. Expandan el conocimiento del agente sobre algo que ya es capaz de hacer. Si
00:06:44pones estas instrucciones en Claude.md, simplemente consumen tokens innecesarios. Las instrucciones específicas del proyecto
00:06:49deberían ir a las habilidades porque se cargan solo cuando el agente realmente las necesita. Puedes
00:06:54también limitar las habilidades a rutas específicas para que solo se activen en la parte relevante del código
00:06:59y no bloqueen el contexto fuera de eso. Por ejemplo, si estás trabajando en el área de implementación,
00:07:04puedes especificar la ruta de ese directorio en la descripción de la habilidad para que la habilidad nunca se cargue cuando
00:07:09estás trabajando en otra parte. Para configurar habilidades, simplemente invocas el creador de habilidades que ahora viene integrado
00:07:14en Claude Code. Anteriormente, tenías que obtenerlo de código abierto desde GitHub, luego respondes las preguntas
00:07:19que te hace durante la sesión de discusión. Tendrás una habilidad adaptada a tus necesidades exactas, que
00:07:23puedes acceder una vez que reinicies la sesión. Además de las habilidades, también puedes usar complementos (plugins). Los plugins son un
00:07:29paquete de habilidades, hooks y MCP disponibles como un paquete único, descargable y distribuible. Así
00:07:34que quien instale este plugin tendrá exactamente el mismo contexto y configuraciones disponibles
00:07:39para su uso de inmediato. Así que si trabajas en equipo, crear tus propios plugins para distribuir
00:07:44a tus compañeros de equipo se vuelve muy importante. Si configuras todas tus configuraciones en un solo lugar, esa información
00:07:49puede ser distribuida en toda la organización para que los miembros de tu equipo tengan el mismo contexto que tú. Puedes
00:07:54hacer esto creando tus propios plugins y gestionándolos, ya sea cargándolos manualmente o sincronizándolos
00:07:59con un repositorio de GitHub. Puedes instalar cualquier plugin usando el comando plugin y puedes
00:08:03navegar por el mercado e instalar el que quieras. También puedes agregar otros mercados usando
00:08:08el comando add plugin marketplace. Claude Code también viene integrado con múltiples plugins como
00:08:13diseño front-end, revisión de código, simplificador de código, Playwright y otros, todo desde el mercado oficial
00:08:18de Claude. Puedes usarlos directamente en tu flujo de trabajo y también puedes crear los tuyos propios.
00:08:22Los plugins importan, especialmente para proyectos a gran escala, porque muchas personas trabajan en el mismo proyecto
00:08:27y distribuir el contexto entre ellas es importante. Así que en lugar de hacer que cada persona descargue habilidades
00:08:32y otros componentes por separado, pueden instalar el plugin directamente. Además, si estás disfrutando de nuestro
00:08:36contenido, considera presionar el botón de hype porque nos ayuda a crear más contenido como este y llegar
00:08:41a más personas. Otra cosa que importa en los armazones de agentes, pero de la que no se habla lo suficiente, es
00:08:46LSP. El protocolo de servidor de lenguaje o LSP es básicamente una integración que le da al agente el mismo tipo
00:08:52de navegación que un desarrollador tiene en un IDE. Hay un LSP para casi cualquier lenguaje de programación y
00:08:58podría ser innecesario con los populares, pero se vuelve crítico con los no convencionales. Le
00:09:03da al agente inteligencia sobre el lenguaje de programación para que pueda navegar por la base de código de la forma en que
00:09:08lo hace un humano. Por ejemplo, cuando un humano quiere encontrar una función, verifica de dónde
00:09:13se importa esa función, va a ese archivo y verifica ese archivo para ver la definición de la función. Así es como
00:09:17realmente encuentran la fuente exacta que necesitan. Sin LSP, el agente busca patrones basados en
00:09:22texto y es probable que aterrice en el símbolo incorrecto. Como mencionamos, Claude Code usa el enfoque basado en el sistema de archivos
00:09:28con comandos bash, por lo que sin LSP solo busca patrones en nombres de archivos y texto,
00:09:33no navegando con una inteligencia más profunda. Ahora, no asumas que LSP no es necesario solo porque tu agente
00:09:38aún no ha encontrado errores. Configura LSP incluso antes de empezar a trabajar en el proyecto. Configúralo para
00:09:44todos los lenguajes que usarás, incluso antes de escribir cualquier código, para que el agente ya tenga información sobre
00:09:49cómo trabajar con ellos. En lugar de dejar que el agente adivine patrones, instalar LSP le permite leer y editar
00:09:55código de la forma en que un desarrollador piensa sobre él, no solo como texto. Ahora, como ya sabes, MCP se utiliza para
00:10:00conectar el agente a herramientas externas, pero también puedes conectar tus MCP a las herramientas internas, fuentes de datos,
00:10:05APIs u otros sistemas que el agente no podría alcanzar de otro modo. Para eso, necesitas
00:10:10crear tus propios MCP y ponerlos a disposición para que las personas de tu equipo puedan usarlos fácilmente. Los MCP
00:10:16son básicamente una extensión de la configuración existente, cargada siempre que se necesite, y las herramientas que
00:10:20proporcionan están disponibles para que el agente las use. Si estás trabajando en una gran base de código, puedes construir
00:10:25MCP que sirvan para muchos propósitos, como actuar como una guía de documentación, recuperar análisis o incluso
00:10:31permitirte realizar cambios a través de ellos. Estos son útiles porque, si tienes tu propia base de código, puedes
00:10:35dejar que el agente interactúe naturalmente con información interna, llame a herramientas y realice cambios allí
00:10:40en lugar de hurgar entre una documentación enorme. Esto le da al agente un acceso más directo a la
00:10:45información y los sistemas que necesita. Pero para configurar un MCP, la configuración básica de la aplicación ya debe
00:10:51estar funcionando. Si configuras tu MCP antes de eso, las cosas pueden salir mal y la implementación del MCP puede
00:10:57fallar. Así que primero asegúrate de que tu aplicación funcione correctamente, luego crea el MCP y deja que el agente
00:11:02interactúe con tu proyecto con más inteligencia y mejor información. Otra cosa que necesitas
00:11:06crear son subagentes. Los subagentes contienen ventanas de contexto aisladas propias y realizan cualquier tarea
00:11:12que les delegue el agente orquestador principal, y luego devuelven solo el resultado final al padre.
00:11:17Esta es una parte clave del armazón de un agente, porque usar subagentes adecuadamente no bloquea la ventana de contexto
00:11:22y hace que la utilización del contexto sea mucho mejor, ya que no llenan el contexto del agente principal
00:11:28con información que no necesita. Los subagentes solo se ejecutan cuando se invocan y luego devuelven sus hallazgos.
00:11:33Claude crea subagentes por su cuenta, pero también puedes configurar subagentes tú mismo. Puedes
00:11:38configurar qué herramientas y modelos quieres para ellos y proporcionar instrucciones sobre cómo deberían
00:11:42operar, creando agentes específicos para tus propios flujos de trabajo. También puedes anular los agentes existentes de Claude;
00:11:47por ejemplo, puedes crear tu propio agente cuyas instrucciones anulen las existentes, como
00:11:52explorar y proporcionar una descripción sobre cómo debería navegar por tu directorio. El agente de exploración propio
00:11:57de Claude está generalizado para todo tipo de bases de código, pero si configuras el tuyo propio, el personalizado
00:12:03anula el predeterminado. Esto le da al agente más contexto sobre cómo están estructurados los archivos en tu proyecto,
00:12:08así que no desperdicia tokens navegando archivos confiando solo en la información de Claude.md.
00:12:13Así que puedes hacer que el agente principal controle toda la ejecución del proyecto y confiar en los subagentes para el
00:12:18trabajo real. Los subagentes también ayudan porque puedes paralelizar su trabajo mediante la delegación de agentes,
00:12:23lo que hace que el flujo de trabajo sea mucho más fluido y rápido que hacerlo todo secuencialmente.
00:12:28Hay algunas prácticas más que debes seguir al navegar por una base de código grande.
00:12:32Esto es importante porque la capacidad de Claude para navegar por una base de código grande está determinada por
00:12:36si es capaz de encontrar el contexto correcto. Así que asegurarse de que Claude obtenga el contexto correcto es
00:12:41importante para que el agente no reciba demasiado poco o demasiado y se mantenga enfocado. Además de separar
00:12:46el archivo Claude.md, necesitas separar las pruebas para cada subdirectorio en lugar de tenerlas todas en un
00:12:51lugar. De esta manera, se mantienen segmentadas, evitan problemas de tiempo de espera cuando se ejecutan muchas pruebas a la vez y pueden
00:12:56ser limitadas de manera más efectiva. También puedes crear un archivo de mapa de base de código por separado que mapee la estructura
00:13:01de tu proyecto. Si estás trabajando con aplicaciones convencionales como React o Next.js, puedes omitir esto
00:13:06porque los agentes han sido entrenados extensamente en esas. Pero con lenguajes no convencionales como C++
00:13:12necesitas un mapa de base de código. Actúa como una tabla de contenido para el agente, permitiéndole saber dónde
00:13:16vive cada archivo en lugar de ejecutar muchos comandos bash para reducir la búsqueda al correcto. Por último,
00:13:21pero más importante aún, revisa tu configuración cada pocos meses a medida que el modelo evoluciona. Elimina las instrucciones,
00:13:26hooks o cualquier otra cosa que el modelo más nuevo ya no necesite. Usa archivos .ignore como .gitignore
00:13:32y .agentignore para que los archivos que no quieres que el agente o el control de versiones toquen se dejen solos.
00:13:37De esta manera, tu configuración podrá sostenerse en aplicaciones a gran escala. Ahora, los recursos para este
00:13:41video se pueden encontrar en AI Labs Pro para este video y para todos nuestros videos anteriores, desde donde puedes
00:13:46descargar y usarlo para tus propios proyectos. Si has encontrado valor en lo que hacemos y quieres apoyar al
00:13:51canal, esta es la mejor manera de hacerlo. Los enlaces están en la descripción. Eso nos lleva al final de
00:13:55este video. Si te gustaría apoyar al canal y ayudarnos a seguir haciendo videos como este, puedes
00:14:00hacerlo usando el botón de super gracias a continuación. Como siempre, gracias por ver y te veré en el próximo.

Key Takeaway

El éxito de los agentes de codificación en proyectos a gran escala depende de un armazón robusto y modular que integre Claude.md, hooks específicos, habilidades bajo demanda y subagentes en lugar de depender únicamente de la potencia del modelo.

Highlights

  • Los agentes de codificación basados en el sistema de archivos superan a los sistemas RAG al utilizar comandos bash (ls, grep) para reducir la búsqueda al fragmento de código exacto necesario.

  • El archivo Claude.md debe mantenerse por debajo de las 300 líneas para evitar distracciones en la ventana de contexto del agente.

  • La segmentación de archivos Claude.md en subdirectorios permite al agente cargar instrucciones enfocadas progresivamente en lugar de extraer todo desde un archivo raíz.

  • Los hooks de detención obligan al agente a reflexionar tras finalizar una sesión, permitiéndole actualizar Claude.md con los aprendizajes obtenidos para evitar problemas recurrentes.

  • La implementación de subagentes con ventanas de contexto aisladas previene la saturación del contexto del agente principal, mejorando la eficiencia y permitiendo la paralelización de tareas.

  • El uso de Language Server Protocol (LSP) dota al agente de una navegación de código inteligente similar a la humana, evitando errores comunes de búsqueda basada únicamente en patrones de texto.

Timeline

Limitaciones de la navegación RAG y adopción del sistema de archivos

  • Los sistemas basados en RAG fallan en bases de código grandes debido a la alucinación de módulos y problemas de coincidencia semántica.
  • La navegación basada en el sistema de archivos, empleada por agentes como Claude Code, utiliza herramientas bash para localizar fragmentos de código específicos.

La búsqueda semántica tradicional sobre toda una base de código contamina la ventana de contexto con datos innecesarios. El enfoque en comandos bash permite al agente actuar como un desarrollador humano, reduciendo la búsqueda hasta el código exacto antes de cargarlo, lo cual es más eficaz para escalar.

Optimización del armazón: Claude.md y hooks

  • Un armazón de agente eficaz requiere configuraciones adaptadas al proyecto específico, más allá de las capacidades del modelo base.
  • El archivo Claude.md funciona como base de conocimientos central, pero debe ser breve y distribuido por subdirectorios en proyectos grandes.
  • Los hooks de shell, como los de inicio, salida y detención, fuerzan al agente a ejecutar acciones obligatorias que las instrucciones escritas pueden pasar por alto.

La centralización de convenciones en un solo archivo ineficiente distrae al agente. La distribución de reglas en subdirectorios asegura que las instrucciones se carguen solo cuando son necesarias. Los hooks actúan como mecanismos de control forzoso, permitiendo la integración de pruebas y la actualización automática de conocimientos tras cada sesión.

Escalabilidad mediante habilidades, plugins y LSP

  • Las habilidades cargan instrucciones especializadas solo bajo demanda para ahorrar tokens.
  • Los plugins permiten empaquetar habilidades, hooks y MCP para distribuir configuraciones consistentes en equipos de trabajo.
  • La integración de LSP es crítica para que el agente navegue por lenguajes no convencionales mediante una comprensión real de la estructura del código.

El uso de divulgación progresiva con habilidades evita el bloqueo innecesario de la ventana de contexto. Los plugins resuelven la necesidad de sincronización en equipos grandes. Por su parte, el LSP proporciona al agente la capacidad de entender la definición de funciones y las importaciones, superando las limitaciones de buscar solo nombres de archivos.

Uso de MCP, subagentes y prácticas de mantenimiento

  • Los MCP conectan el agente con APIs y datos internos, pero requieren que la aplicación sea funcional antes de su implementación.
  • Los subagentes permiten delegar tareas a contextos aislados, mejorando la eficiencia y permitiendo el trabajo en paralelo.
  • El mantenimiento periódico del archivo de configuración, incluyendo la limpieza de instrucciones obsoletas, garantiza la viabilidad del proyecto a largo plazo.

La delegación en subagentes optimiza el uso de la ventana de contexto del orquestador principal. Para proyectos complejos o lenguajes como C++, un mapa de base de código actúa como tabla de contenido esencial. La revisión constante de archivos .ignore y la actualización de instrucciones según evoluciona el modelo base son necesarias para mantener el sistema funcional.

Community Posts

No posts yet. Be the first to write about this video!

Write about this video