00:00:00Claude Code se lanzó de forma general el 22 de mayo del año pasado, junto con Claude 4.
00:00:06Pero también hubo una versión de prueba previa, por lo que he estado usando la herramienta
00:00:11desde hace poco más de un año, y de hecho hice los cálculos. Si sumas todo el tiempo
00:00:15que me tomó escribir prompts, revisar el código y monitorearlo, he usado la herramienta por más de 2000
00:00:21horas. Así que sí, tengo un par de cosas que enseñarte. Eso es lo que quiero hacer en este video.
00:00:27Ahora mismo, quiero compartir con ustedes todas mis estrategias probadas en batalla que los llevarán
00:00:31de ser un usuario básico de Claude Code a ser un usuario avanzado. He agrupado todo en lo que
00:00:37llamo el marco WISC. Y la cuestión es que estas estrategias son legítimas. No soy uno de esos
00:00:43creadores de contenido de IA que se subió al carro de Claude Code en los últimos meses. He estado
00:00:48usando esta herramienta, como dije, a diario durante más de un año. Por eso, estas estrategias funcionarán en
00:00:54cualquier base de código, incluso en las masivas o proyectos con múltiples bases de código. He visto todo esto
00:01:00aplicado a nivel empresarial, así que no importa en qué estés trabajando, esto es para ti. Esto también
00:01:05funciona para cualquier asistente de programación con IA. Me enfoco en Claude Code porque es el mejor en este
00:01:10momento. Asumo que ya tienes al menos un conocimiento básico de Claude Code y que ahora
00:01:15quieres pasar al siguiente nivel. Si buscas lo básico sobre cómo crear un sistema de programación con IA,
00:01:21dejaré un enlace a ese video justo aquí. Todas estas estrategias son para cuando queremos
00:01:25trabajar en bases de código reales que se vuelven complicadas, porque tenemos muchas estrategias sobre la
00:01:32gestión del contexto. Esto es vital porque la degradación del contexto es el mayor problema de los asistentes de IA
00:01:38actualmente. No importa que tengamos el nuevo límite de un millón de tokens en Claude Code, aun
00:01:43así debemos tratar nuestro contexto como el recurso más preciado, el cual debe ser diseñado cuidadosamente
00:01:49con nuestros asistentes de IA. Así que las letras W, I, S y C del marco representan estrategias
00:01:56que se aplican a eso, y son cosas que puedes tomar y aplicar a tus proyectos de inmediato.
00:02:00Se los voy a explicar de forma muy sencilla. Ahora, la pregunta que podrías hacerte
00:02:05es: Cole, ¿por qué nos enfocamos tanto en la gestión del contexto? ¿Después de 2000 horas usando
00:02:11Claude Code, esto es en lo que quieres centrarte? Y mi respuesta es sí. Sé que es muy específico,
00:02:17pero debemos abordar la degradación del contexto y cómo evitarla. Me atrevería a decir
00:02:23que cerca del 80% de las veces que tu agente de programación falla en tu base de código, es porque
00:02:28no estás gestionando el contexto lo suficientemente bien. Por eso, quiero empezar con el problema de la degradación,
00:02:33y luego pasaremos rápidamente a la práctica analizando cada parte del marco WISC. Pero quiero
00:02:38empezar con la degradación del contexto como preámbulo para que vean el porqué. Una vez que apliquen el marco WISC,
00:02:45verán de inmediato saltos en la fiabilidad de su programación con IA, incluso en bases de código
00:02:50desordenadas. Sigo enfatizando las bases de código grandes y complejas porque es ahí donde la degradación
00:02:56del contexto se vuelve un problema cada vez mayor. Ahora bien, ha habido mucha investigación en la industria sobre
00:03:02la degradación del contexto, pero mi favorita, que es la más práctica y probablemente la más popular, es el Informe
00:03:07Técnico de Chroma que cubre cómo el aumento de tokens de entrada afecta el rendimiento de los LLM. La idea principal
00:03:13es que solo porque puedas meter cierta cantidad de tokens en la ventana de contexto de un LLM no significa
00:03:18que debas hacerlo. Y sí, esto se aplica a Claude Code con el nuevo límite de 1 millón de tokens.
00:03:24Porque los modelos de lenguaje extensos se abruman con la información igual que las personas. Se llama el
00:03:30problema de la aguja en el pajar. Cuando tienes un dato muy específico o, con los agentes de programación,
00:03:35un archivo específico que ha leído y que necesitas que recuerde, hará un buen trabajo recordando
00:03:41esa información en su memoria a corto plazo, pero solo si no tienes una ventana de contexto superllena.
00:03:47Cuando empiezas a tener una cantidad masiva de contexto cargado, aparecen lo que se llaman
00:03:52distractores. Estos son fragmentos de información cercanos o similares a lo que necesitas que el LLM
00:03:58recuerde, pero no son exactamente lo correcto. Vemos esto mucho en la programación con IA, especialmente en bases de
00:04:04código grandes. Seguimos los mismos patrones en toda nuestra base de código. Hay mucha
00:04:09similitud en cómo se implementan las diferentes partes. Por eso, los modelos de lenguaje
00:04:14extraerán la información errónea y estarán muy seguros de su corrección o implementación. Estoy seguro de que
00:04:19han visto esto todo el tiempo. El problema de la aguja en el pajar ocurre constantemente
00:04:24en la programación con IA. Esta es la idea de la degradación del contexto. Cuanto más grande es nuestra ventana, más
00:04:30le cuesta al modelo de lenguaje extraer exactamente lo que necesitamos para el turno actual con nuestro
00:04:36agente. Volviendo al diagrama, permítanme ser superespecífico. Lo que estamos abordando con
00:04:42todas estas estrategias es la pregunta: ¿cómo mantenemos nuestra ventana de contexto lo más ligera posible
00:04:48dándole al agente de programación todo el contexto que necesita? Esa es la ingeniería de contexto
00:04:53que estamos haciendo aquí. Así que voy a repasar cada estrategia. Incluso tengo
00:04:57un ejemplo para cada una que revisaré en vivo con ustedes en una base de código complicada, y todos
00:05:02los comandos, reglas y documentos que uso como ejemplo, los tengo en esta carpeta que enlazaré
00:05:06en la descripción. Así podrán usar todas estas estrategias conceptualmente, pero también con estos
00:05:12comandos de ejemplo que tengo en la carpeta .claude justo aquí. Bien, entremos en las
00:05:17estrategias individuales. W es por Write (escribir), I por Isolate (aislar), S por Select (seleccionar) y C por Compress (comprimir). Y
00:05:24por supuesto, empezaremos con la W, que es escribir, externalizando la memoria de nuestro agente.
00:05:30Queremos capturar tanto como sea posible las decisiones clave y en qué ha estado trabajando el agente
00:05:34para que en futuras sesiones podamos poner al agente al día mucho más rápido y tener que gastar menos
00:05:40tokens al inicio para que el agente entienda lo que realmente necesitamos que haga. Así que la primera estrategia
00:05:46aquí es usar el log de git como memoria a largo plazo. Y esto me encanta porque hay
00:05:52muchas personas a las que les encanta complicar las cosas con marcos de memoria supercomplejos para sus
00:05:56agentes, pero en realidad todo el mundo ya usa git y GitHub para el control de versiones. Así que podemos
00:06:01aprovechar una herramienta que ya estamos usando para proporcionar memoria a largo plazo a nuestro agente. Vamos
00:06:07a nuestra base de código y les mostraré a qué me refiero. La base de código que usaré para todos los
00:06:12ejemplos es el nuevo Archon. He estado trabajando arduamente en esto los últimos meses
00:06:18tras bambalinas. Este es su centro de mando de IA donde pueden crear, gestionar y ejecutar flujos de trabajo
00:06:23de programación de IA de larga duración. Incluso estamos trabajando en un constructor de flujos. Va a ser como el
00:06:28N8N para la programación con IA. Podemos iniciar flujos de trabajo, ver los logs y monitorearlos en nuestro
00:06:33centro de control. Podemos mirar ejecuciones pasadas para ver exactamente qué pasó. Por ejemplo, este es un flujo
00:06:39muy largo que tengo para validar pull requests completos en mi código. Como pueden
00:06:44ver al observar esto y mucho más que vendrá pronto en Archon, por cierto, pueden notar que
00:06:47hay muchas partes móviles. Es una base de código muy complicada. Por eso es
00:06:51un buen ejemplo para todo lo que voy a cubrir aquí, todas las estrategias.
00:06:57Sobre el uso de git como memoria a largo plazo, les mostraré un ejemplo aquí de un comando de una sola línea
00:07:03para todos mis mensajes de commit recientes. Lo que quiero destacar es que tenemos una forma
00:07:09muy estándar de crear estos mensajes de commit. Tenemos nuestras fusiones, pero también todas estas
00:07:13implementaciones de funciones y correcciones. Mantengo todo estandarizado porque así puedo confiar
00:07:19en los mensajes de commit para decirle a mi agente de programación en qué he trabajado recientemente, ya que muchas
00:07:24veces eso nos guiará sobre lo que queremos trabajar a continuación. Y la razón por la que lo tengo tan
00:07:29estandarizado es porque hay un comando de commit que ejecuto. Hacer un git commit es muy fácil,
00:07:36pero si queremos estandarizar el mensaje y que el agente de programación nos ayude con eso,
00:07:40tener un comando específico es muy potente. Tengo esta implementación completa que hice aquí
00:07:46en una sola ventana de contexto con el agente de programación. Estoy al final y ya estoy listo para hacer mi
00:07:51commit. Si solo escribo /commit, eso es todo lo que tengo que hacer. Ejecuta este comando que
00:07:55tiene la estandarización de cómo documento cualquier trabajo realizado. Y también cualquier mejora
00:08:01en mis reglas o comandos. Es un comando de dos partes: qué construimos y cómo mejoramos la
00:08:06capa de IA. Hará el commit y les mostraré cómo queda después.
00:08:10Bien. Al ver nuestro mensaje de commit, vemos que hicimos algunas mejoras de prueba
00:08:14en la CLI. Un prefijo muy claro y luego los detalles. Y además, para que el agente de
00:08:19programación sepa cómo evolucionan sus propias reglas y comandos, incluimos eso en el mensaje
00:08:23de commit siempre que encontramos la oportunidad de mejorar, por ejemplo, nuestro comando de planificación. Por
00:08:29supuesto, este comando de commit es uno de los recursos que tengo para ustedes en el repositorio. Si quieren
00:08:33usarlo como punto de partida, pero también los animo a personalizar cómo se ven sus mensajes de
00:08:37commit. Lo importante es estandarizar los mensajes. Los hacemos muy detallados
00:08:41para usarlos como memoria a largo plazo. Bien. La segunda estrategia de escritura es
00:08:47empezar siempre una ventana de contexto nueva cada vez que vayas a escribir código. Sin importar en qué esté trabajando,
00:08:53mi flujo siempre es: tengo una conversación para planificar con el agente. Creo algún tipo de
00:08:57markdown que tenga mi plan estructurado. Y luego envío eso como el único contexto a una
00:09:03sesión nueva para la implementación. Es crucial que tu especificación tenga todo el
00:09:08contexto que el agente necesita para escribir el código y validarlo. Por ejemplo, en esta conversación,
00:09:14solo estoy planificando. Ejecuto mi comando 'prime' para empezar. Hablaré de esto en un momento.
00:09:18Cargo el contexto y luego creo mi plan con este comando. Es otro que tengo como
00:09:24recurso para ustedes. Básicamente guía al agente paso a paso: esta es la estructura exacta
00:09:28que queremos crear para nuestro documento markdown único. Pasamos de nuestra memoria a corto plazo
00:09:33a un solo documento. Y terminamos la sesión aquí. Vamos a una ventana de contexto nueva
00:09:38y procedemos con la implementación. Uso mi comando 'execute'. Aquí puedo
00:09:42especificar la ruta a mi plan estructurado. Sin ningún otro contexto porque esto debería tener todo lo
00:09:48que necesita. Esto es vital porque mantiene a nuestro agente extremadamente enfocado en la tarea actual.
00:09:53Puede haber mucha investigación y otras cosas que ensucian la ventana de contexto
00:09:57si implementamos en el mismo lugar donde planificamos. La última estrategia de la W para externalizar
00:10:03la memoria del agente son los archivos de progreso y logs de decisiones. Verán esto constantemente en marcos
00:10:08de programación de IA más elaborados donde hay un handoff.md o todo.md para comunicar a
00:10:13diferentes subagentes o equipos de agentes, o incluso entre sesiones del mismo agente. Cuando te estás
00:10:17quedando sin contexto, a menudo quieres crear este resumen de lo que se acaba de hacer. Así
00:10:22puedes ir a una sesión fresca porque empiezas a notar la degradación del contexto con el agente
00:10:27alucinando en conversaciones largas. Obviamente lo ideal es evitar estas conversaciones
00:10:33largas, pero a veces son necesarias. Por ejemplo, algo que hago mucho con Archon es
00:10:38hacer que use la CLI de navegador de Vercel para realizar pruebas de extremo a extremo (E2E). Y
00:10:44así lo hago pasar por muchos recorridos de usuario y pruebas de casos borde. Eso consume mucho
00:10:49contexto. Pueden ver abajo que ejecuté /context y ya estamos en 200,000 del
00:10:56nuevo límite de 1 millón. Esto se llena rapidísimo. Y cuando empiezas a tener unos cientos de miles
00:11:01de tokens en la ventana de contexto, es cuando el rendimiento del agente empieza a degradarse. Así que
00:11:05puedo simplemente ejecutar un /handoff. Este comando creará un resumen que ahora puede pasar a
00:11:11otra sesión para que el agente continúe el trabajo. Pero ahora no tiene cientos de miles de
00:11:16tokens de llamadas a herramientas y cosas así ocupando su ventana. Este comando de handoff solo
00:11:21está siguiendo un proceso de qué es exactamente lo que queremos poner en este documento para que el próximo
00:11:25agente tenga lo necesario. Bien. Eso concluye nuestra W, y cada una de estas estrategias es
00:11:31importantísima porque registramos decisiones clave para que futuras sesiones las retomen rápido.
00:11:36Sé que voy rápido. Déjenme saber en los comentarios si hay alguna de estas
00:11:40estrategias sobre la que quieran un video completo, porque podría hacerlo para cada una.
00:11:45Y ahora pasamos a la I de Isolate (aislar) usando subagentes. Me encanta usar subagentes para todo lo
00:11:52relacionado con investigación; los uso en casi todas las sesiones. Lo importante aquí es mantener
00:11:56limpio tu contexto principal. Podemos usar subagentes para realizar decenas o cientos de miles de
00:12:03tokens de investigación en nuestra base de código o en la web. Y luego solo dar el resumen necesario a nuestra
00:12:10ventana principal de Claude Code. Así, en lugar de cargar decenas de miles de tokens de investigación en nuestra
00:12:16ventana principal, ahora solo son unos 500 tokens. Seguimos obteniendo la información principal
00:12:21que necesitamos, pero con una mejora del 90.2% según investigaciones de Anthropic al usar
00:12:28subagentes para cargar el contexto de investigación, en lugar de que el agente principal se encargue de
00:12:33todo. Déjenme darles un ejemplo rápido. Siempre es al inicio de la
00:12:38conversación o antes de ese plan estructurado que mencioné, cuando estoy planificando. Ahí es
00:12:43cuando uso mucho los subagentes. Miren esto: quiero construir un editor de flujos de trabajo en Archon.
00:12:50Así que quiero que actives dos subagentes, uno para investigar a fondo la base de código para ver cómo
00:12:55integraríamos un editor de flujos y qué significa eso para Archon, y otro subagente
00:13:01para investigar en la web las mejores prácticas para el stack tecnológico. Por ejemplo, si quiero usar React, ¿qué librería
00:13:06deberíamos usar? Y en general, ¿cómo se construyen editores de flujos como Diffy o N8N? Estoy
00:13:12usando mi herramienta de dictado. Envío el prompt. Ahí está. No solo obtenemos el
00:13:16beneficio del aislamiento, sino también velocidad porque usará estos subagentes en paralelo,
00:13:21volverá con un resumen y mi agente principal sintetizará todo para darme la palabra final.
00:13:26Ahí lo tienen. Ambos subagentes corren en paralelo tras bambalinas. Podemos ir y ver
00:13:31los logs de cada uno también. Al final regresará con el
00:13:36informe final. Bien, nuestros subagentes terminaron. En lugar de usar cientos de miles de tokens
00:13:41en nuestra ventana principal, que fue lo que consumieron los subagentes en su investigación,
00:13:46solo usamos 44,000 tokens, solo el 4% de nuestra ventana hasta ahora. Ese es el poder de los subagentes. No los
00:13:53recomiendo para la implementación porque ahí sí quieres todo el contexto de lo que hiciste. Pero para
00:13:57investigación, son muy potentes. Así que el aislamiento y los subagentes son muy importantes para su proceso de
00:14:04planificación. La otra forma de usar subagentes es con lo que llamo el patrón de exploración (scout pattern).
00:14:09Queremos enviar exploradores antes de comprometer tu contexto principal. Puede haber partes de tu base de
00:14:14código o documentación que quieras que los subagentes exploren para ver si es relevante cargarlas en tu
00:14:21sesión principal de Claude Code. Así puede tomar la decisión de antemano. Como: sí, deberíamos
00:14:25traer esto para nuestra planificación mayor, o no, debemos omitirlo, no es relevante. Por ejemplo,
00:14:30con Archon, tengo algunos documentos markdown que analizan a fondo ciertas partes de la base de
00:14:36código, que no es el tipo de contexto que queremos en nuestras reglas porque no lo necesitamos siempre. Pero a veces
00:14:41podrías querer cargarlo, y podrías imaginar que es algo en Confluence o Google Drive,
00:14:45donde sea que guardes tu contexto. Volviendo a esta conversación principal,
00:14:48puedo decir: activa un subagente para investigar todo en .claude/docs. ¿Hay
00:14:54alguna documentación aquí que debamos cargar en nuestro contexto principal para planificar?
00:14:59Lo envío, tomará la decisión y cargará lo que me interesa. Justo aquí,
00:15:04lanzamos un subagente explorador. Encontró toda nuestra documentación y recomendó cargar una.
00:15:09Y yo dije: sí, adelante, cárgala. Esto es muy importante para lo que estamos planeando. Así que
00:15:13en lugar de solo usar subagentes para investigar, a veces tenemos piezas de documentación completas
00:15:18que consideramos cruciales para nuestra ventana de contexto principal. Ahí es cuando usamos el patrón
00:15:23de exploración. Eso es todo sobre aislamiento. Recuerden usar subagentes para su investigación
00:15:28y planificación de forma extensiva. Y ahora llegamos a la S de Select (seleccionar). Carguen su contexto justo a
00:15:34tiempo, no 'por si acaso'. A lo que me refiero es que si no estás
00:15:40100% seguro de que un dato es importante para tu agente de programación ahora, entonces no te molestes en cargarlo. Y
00:15:46tenemos un enfoque por capas para ayudar con esto. Empezamos con nuestras reglas globales. Estas son nuestras
00:15:51restricciones y convenciones que siempre queremos que el agente conozca. Quieres que este
00:15:57archivo sea conciso, normalmente entre 500 y 700 líneas es lo que yo busco. Muchos
00:16:02abogan por incluso menos, pero tienes cosas como tu arquitectura, los comandos a ejecutar, aspectos
00:16:08como tu estrategia de pruebas y registro de logs. Este es mi ejemplo de Archon, pero son cosas de las que
00:16:12quieres que tu agente esté consciente todo el tiempo. Y luego tenemos nuestra capa dos.
00:16:18El contexto bajo demanda, como yo lo llamo. Son reglas que se aplican solo a partes específicas del código.
00:16:23Como si trabajamos en el front-end, que no es siempre, pero si lo haces, aquí están las reglas
00:16:28globales del front-end, o las reglas para crear endpoints de API. Así que añadimos esto
00:16:33a nuestras reglas globales para tipos de tareas específicas, porque no siempre vamos a estar trabajando en
00:16:38el front-end, por ejemplo. Para mostrarles un ejemplo, tenemos la referencia YAML de flujos que
00:16:43obtuve hace un momento con el subagente explorador. Cuando trabajamos en los flujos,
00:16:48nos importa esto, pero no lo queremos en nuestras reglas globales porque la mayor parte del tiempo
00:16:52que trabajamos en Archon, no estamos en esa parte específica de la base de código. Así que
00:16:57es contexto bajo demanda. La tercera capa que tenemos aquí son las habilidades (skills). Esto es muy popular
00:17:05con Claude Code y otros sistemas ahora. Tenemos diferentes etapas donde el agente va a
00:17:10explorar las instrucciones y capacidades de la habilidad conforme considere que realmente las necesita.
00:17:15Empezamos con la descripción. Es una cantidad muy pequeña de tokens cargados al inicio con nuestras
00:17:20reglas globales. Si el agente decide usar esta habilidad, entonces cargará el skill.md completo,
00:17:25que también puede apuntar a otros scripts o documentos de referencia que querríamos cargar si vamos
00:17:29más profundo en la habilidad. Como ejemplo, tengo mi habilidad de navegador del agente. Esto es
00:17:35lo que uso para mi automatización de navegador en todas mis pruebas E2E que mostraba antes. La uso
00:17:40todos los días. Y así, siempre que estoy haciendo mis pruebas E2E, quiero cargar este
00:17:46conjunto de instrucciones para que el agente entienda cómo usar el navegador. Y finalmente, para la cuarta
00:17:52capa, tengo los comandos 'prime'. Todo lo demás que he cubierto es documentación estática
00:17:57que vamos a actualizar de vez en cuando. Pero a veces necesitamos que nuestro agente explore
00:18:02nuestra base de código real. Necesitamos asegurar que toda su información esté totalmente al día
00:18:07y estamos dispuestos a gastar tokens con subagentes al inicio para lograrlo. Eso es
00:18:11lo que hace el comando 'prime': exploramos nuestra base de código al inicio de nuestra planificación
00:18:16para que entienda el código antes de decidir qué construir después. Como pueden ver en mi
00:18:22carpeta de comandos, tengo muchos comandos prime distintos porque hay diferentes partes del código
00:18:27que quiero que el agente entienda según lo que planee construir. Mi comando prime genérico es
00:18:32este que estamos viendo. Solo le pido que obtenga una comprensión de la base de código de Archon
00:18:36a alto nivel. Aquí está paso a paso lo que quiero que lea, incluyendo el log de git
00:18:41porque es importante para usarlo como memoria a largo plazo. También tengo uno especializado,
00:18:47'prime workflows', para cuando sé que trabajaré en el motor de flujos en Archon. Es un comando
00:18:53muy similar pero más especializado. Lo uso al inicio de la conversación para que mi agente pueda
00:18:58cargar rápido todo lo necesario. Confirmo que entiende mi código y luego entro en el
00:19:03proceso de planificación que les mostré antes. En resumen rápido: las reglas globales siempre están
00:19:09cargadas. Contexto bajo demanda cuando vas a trabajar en una parte del código que
00:19:13está documentada aparte. Habilidades cuando necesitas capacidades diferentes, como: 'es hora de hacer
00:19:18pruebas E2E, carguemos la habilidad del navegador'. Y los comandos prime los
00:19:22ejecutaré usualmente al puro inicio de la conversación para preparar mi planificación. Eso es
00:19:28todo para la selección. Ahora vamos a Compress (comprimir), y esta es la sección más rápida de cubrir
00:19:34porque no deberías necesitar comprimir seguido si aplicas bien 'escribir', 'aislar' y 'seleccionar'.
00:19:39Si aplicamos las otras estrategias para mantener el contexto ligero, evitamos esto y
00:19:46es bueno porque quieres evitar comprimir lo más posible. Si de plano debes comprimir, entonces
00:19:52hay un par de estrategias a cubrir aquí. Y esas dos estrategias son el 'handoff' y la
00:19:56compactación enfocada. Vamos a Claude Code y echemos un vistazo. El handoff ya lo
00:20:02vimos, es una de nuestras estrategias de escritura. Resumimos todo lo que acabamos de hacer para
00:20:06pasárselo a otro agente o al mismo agente tras compactar la memoria. Y luego está el comando
00:20:12integrado /compact en Claude Code. Este va a resumir nuestra conversación, luego borrará la
00:20:18conversación y pondrá el resumen al principio de nuestra ventana de contexto. El handoff es muy
00:20:23potente porque ahí definimos nuestro propio flujo de cómo recordar la información. Pero
00:20:28el /compact también es muy útil, especialmente porque opcionalmente podemos dar instrucciones de
00:20:34resumen. Cuando forzosamente tengo que compactar, uso esto siempre. Por ejemplo:
00:20:41"enfócate en los casos borde que acabamos de probar". Así, cuando cree ese resumen, le prestará
00:20:48más atención a esa parte de su memoria a corto plazo. No lo escribí bien, pero no importa.
00:20:53Ejecutará la compactación aquí. El handoff y el /compact son como opciones alternativas.
00:20:58Pero hallo momentos donde quiero usar ambos. El handoff sobre todo cuando llegas a una
00:21:03compactación más de dos veces; usualmente esa conversación ya está muy saturada, así que mejor abres una
00:21:09sesión nueva con el handoff. Pero si solo es una vez, muchas veces me basta con ejecutar
00:21:14un /compact una vez. Aunque después de compactar, igual le pediré al agente que resuma lo que
00:21:19recuerda para asegurarme de que de verdad entendió, algo como: "¿qué recuerdas
00:21:24de aquí?". Así que sí, no es lo ideal. Eviten la compactación lo más posible.
00:21:30La mejor estrategia de compresión es no necesitar compresión. Muy bien, ese es el
00:21:36marco WISC. Sé que fue mucho, así que espero que les haya sido útil. Avísenme si hay alguna
00:21:41estrategia en la que quieran que profundice, porque podría hacer un video entero sobre cualquiera de
00:21:46ellas. Pero este es el marco WISC. Espero que puedan usarlo para pasar al
00:21:52siguiente nivel de Claude Code o de cualquier asistente de programación con IA. Si este video les gustó
00:21:59y esperan más contenido sobre programación con IA y cómo aplicar este tipo de
00:22:04marcos en la práctica, agradecería mucho un 'like' y que se suscriban. Con eso, los veré
00:22:09en el próximo video. ¡Psst! Tengo una última cosa muy rápida que no querrán perderse.
00:22:14El 2 de abril organizaré un taller gratuito de transformación de IA en vivo en mi canal de YouTube junto
00:22:20con Lior Weinstein, fundador de CTOX, y esto es algo importante. Lior nos enseñará cómo
00:22:27reestructurar toda nuestra organización para la IA, y luego yo les enseñaré a dominar la metodología
00:22:32de programación con IA que uso para construir sistemas fiables y repetibles para mis agentes. Así que
00:22:38dejaré un enlace en la descripción a esta página. Será en vivo en mi canal de YouTube, así que
00:22:42pueden activar las notificaciones haciendo clic en este botón. ¡Los veo allí!