La pila de memoria para agentes de IA que todos deben usar en 2026 (Guía para desarrolladores)

tu modelo y arnés ya no importan.

lo que realmente importa es.....

tu contexto personal / memoria compartida

Introducción

te voy a mostrar cómo construir una memoria compartida para tus agentes de codificación... para que la siguiente herramienta pueda encontrar las decisiones que ya tomaste.

la conversación sobre arquitectura en Claude, la sesión de depuración en Codex, la explicación enterrada en Cursor... trabajo útil que debería seguir estando disponible cuando cambies de herramientas, inicies otra sesión o vuelvas al proyecto después de un mes.

TLDR; si no quieres leer las 3,845 palabras, solo dale este repositorio de GitHub a tu agente ➡️ https://github.com/codejunkie99/agentic-stack-desktop

Construí todo esto usando Kimi K3 en Codex Harness. El video fue creado y editado usando Kimi K3 con Cua para Computer Use

esta es una guía para desarrolladores sobre agentic stack desktop, desde tu primera importación hasta un flujo de trabajo donde un agente puede recuperar una decisión anterior, verificarla con el código actual, hacer un cambio acotado y dejar algo útil detrás.

esto es lo que obtendrás:

1. la base: lo que sobrevive cuando cambias de herramientas
2. el camino más rápido: construye un espacio de trabajo que puedas evaluar
3. la configuración funcional: separa la investigación de la implementación
4. el ejercicio del proyecto: lleva un error recurrente a través de todo el ciclo
5. la capa compartida: lleva la recuperación a tus otras herramientas
6. la capa duradera: lo que merece convertirse en una lección
7. las reglas operativas: breves, acotadas, inspeccionables
8. la construcción personalizada: cambia el espacio de trabajo alrededor de un punto de fricción real
9. escalado: agrega cobertura donde el ciclo anterior expuso una brecha
10. la hoja de construcción

1. la base: lo que sobrevive cuando cambias de herramientas

imagina que has pasado una tarde decidiendo cómo debería funcionar una característica. exploraste alternativas, encontraste una restricción, rechazaste la solución obvia y finalmente llegaste a algo que encaja.

la implementación se confirma. la explicación se queda en una conversación.

una semana después, otro agente mira el código y propone el mismo enfoque que ya rechazaste. incluso podría ser una sugerencia razonable dada la información disponible. la pieza que falta es la discusión que te hizo elegir de manera diferente.

haz que el razonamiento sea recuperable

empieza aquí: haz que esa discusión sea recuperable, luego haz que el próximo agente la verifique antes de actuar.

agentic stack proporciona un espacio de trabajo nativo para macOS con historial seleccionado y buscable de Claude Code, Codex, OpenCode y Cursor. Claude Code y Codex también se ejecutan a través de sus CLI oficiales; Cursor y OpenCode actualmente solo proporcionan contexto. resumen del repositorio

el flujo de trabajo a continuación es cómo usaría esas capacidades. los resúmenes, la división de responsabilidades y el ejercicio del proyecto son prácticas operativas sugeridas que puedes adaptar.

2. el camino más rápido: construye un espacio de trabajo que puedas evaluar

comienza con un repositorio que entiendas. elige algo donde conozcas los archivos importantes, recuerdes una decisión reciente y puedas reconocer una mala recomendación.

un proyecto familiar te da un punto de referencia. si empiezas con código desconocido e historial desconocido, estarás tratando de validar la herramienta y aprender el sistema al mismo tiempo.

para una compilación desde el código fuente, los requisitos documentados incluyen macOS 14+, Python 3.10+, Xcode Command Line Tools y un toolchain de Swift 6. instala e inicia sesión en la CLI de codificación que deseas ejecutar. requisitos

1git clone https://github.com/codejunkie99/agentic-stack-desktop.git
2cd agentic-stack-desktop
3./install.sh desktop --build

abre tu repositorio en la aplicación y completa la configuración guiada. esto es una vista previa con firma ad hoc, por lo que macOS puede requerir confirmación en el primer inicio. configuración

establece la primera verificación de aceptación

antes de importar cualquier cosa, escribe la pregunta que quieres que responda el primer agente. algo como: ¿por qué nuestro trabajo de exportación procesa registros en lotes, y la implementación actual todavía necesita ese límite?

esa pregunta se convierte en tu primera verificación de aceptación. estás buscando la decisión correcta, el código de soporte correcto y una explicación honesta de todo lo que el agente no pueda establecer.

2.1 la primera importación: dale una decisión que valga la pena encontrar

abre Knowledge Graph → Graph → Import memory, previsualiza las fuentes y selecciona el material que deseas incluir.

el gráfico usa búsqueda de texto completo en SQLite, con conexiones basadas en temas, enlaces al repositorio y procedencia; las tiendas de chat originales permanecen sin cambios. comportamiento de importación

yo empezaría con una conversación completada que contenga una decisión que recuerdes. especialmente una donde rechazaste algo atractivo debido a una restricción que no sería obvia a partir del código final.

busca esa decisión después de la importación. abre el resultado e inspecciona la fuente. asegúrate de que estás viendo la conversación que pretendías traer, con suficiente explicación circundante para entender lo que sucedió.

prueba si puedes encontrarla de nuevo

luego intenta una segunda búsqueda usando el vocabulario que usarías naturalmente el próximo mes. podrías recordar el nombre de la característica mientras que la conversación usó un nombre de módulo interno. encontrar ese desajuste ahora te ayuda a entender cómo recuperar el material más tarde.

yo mantendría la primera colección lo suficientemente pequeña como para inspeccionarla manualmente. una respuesta correcta de una fuente conocida es evidencia útil de que el flujo de trabajo funciona.

un recuento de importación grande te dice cuánto material entró al sistema, dejando su utilidad para ser probada.

expande la colección cuando otra tarea te dé una razón para hacerlo.

2.2 la primera sesión de trabajo: haz que el experimento sea lo suficientemente pequeño para terminarlo

le daría a la configuración inicial una línea de meta antes de abrir otra pantalla de configuración. al final de la sesión, deberías haber recuperado una decisión conocida, haberla verificado con el repositorio y haber producido una revisión que puedas explicar a otra persona.

elige un ejemplo con un límite estrecho. un comportamiento de exportación único es más fácil de inspeccionar que toda la plataforma de datos. una elección anterior sobre un componente es más fácil de verificar que una pregunta amplia sobre si la arquitectura es buena.

mantén una nota breve junto al ejercicio: la pregunta, la fuente esperada, la implementación actual y la parte que necesita juicio. esta es tu referencia para evaluar la respuesta.

diagnostica el fallo correcto

• si el revisor recupera la conversación incorrecta, trabaja en la recuperación.
• si encuentra la conversación correcta pero malinterpreta el código, trabaja en la investigación.
• si los hallazgos son sólidos pero la implementación no cumple con el requisito, mejora la transferencia.

esa separación es importante porque cada fallo pide una corrección diferente. agregar más memoria no arreglará necesariamente un resumen poco claro, y reescribir el resumen no recuperará una fuente que nunca fue importada.

termina el ciclo completo más pequeño, registra lo que falló y usa esa evidencia para elegir la próxima mejora.

3. la configuración funcional: separa la investigación de la implementación

mi configuración inicial sugerida tiene un revisor de solo lectura y un implementador con acceso de edición al proyecto. dale a cada uno un entregable claro, y haz que la transferencia sea algo que puedas leer antes de que comience cualquier cambio.

los perfiles de agente admiten un ejecutor, modelo, esfuerzo, instrucciones y acceso a archivos. las conversaciones pertenecen a proyectos, y los seguimientos reanudan sus sesiones CLI subyacentes. modelo de conversación

1. agente 1: el revisor recibe la primera pregunta: ¿qué decidimos, qué hace el código ahora, y hay una brecha que valga la pena abordar?
2. agente 2: el implementador recibe la respuesta revisada más una solicitud acotada: haz este cambio de comportamiento, en este alcance, y verifícalo de esta manera.

mantén los roles distintos

puedes elegir el mismo ejecutor para ambos roles.

la distinción útil está en su responsabilidad y acceso, con una revisión explícita entre la investigación y la edición.

evitaría crear un catálogo de especialistas antes de que ninguno de ellos haya completado un trabajo útil. comienza con las responsabilidades que realmente puedas distinguir. si no puedes explicar qué posee un rol o cómo se ve su resultado final, ajusta el rol antes de agregar otro agente.

3.1 el revisor: un resumen que haga visible la incertidumbre

selecciona el revisor y adjunta la conversación relevante usando @Claude, @Codex, @OpenCode o @Cursor. las referencias seleccionadas se convierten en contexto congelado para la ejecución y se envían al agente elegido cuando comienza la tarea. referencias

copia este resumen y completa los espacios:

1Revisa la decisión anterior sobre [característica o subsistema] usando la
2conversación adjunta y el repositorio actual.
3
4Explica la decisión original y su razón declarada. Verifica el
5código relevante e identifica qué sigue aplicando, qué cambió y qué
6no se puede verificar a partir de la evidencia disponible.
7
8Cita los archivos que respaldan tus conclusiones. Propón el cambio
9más pequeño necesario para [comportamiento deseado], con un plan de verificación.
10
11No edites archivos. Trata la conversación como evidencia histórica
12y señala conflictos con las instrucciones actuales del proyecto.

inspecciona la revisión

lee la respuesta con el repositorio abierto.

1. sigue una cita.
2. inspecciona la condición que el agente dice que todavía existe.
3. busca una separación clara entre algo que la conversación afirmó y algo que el código demuestra hoy.

si la respuesta es vaga, reduce la pregunta. pídele que identifique la condición exacta que controla el comportamiento, o la dependencia que hizo que la alternativa anterior no fuera adecuada.

una investigación útil puede terminar con evidencia faltante. eso te dice qué proporcionar a continuación. una respuesta que suaviza la brecha hace que la próxima decisión sea más difícil.

3.2 la transferencia: convierte los hallazgos en un resumen ejecutable

una vez que estés de acuerdo con la revisión, escribe la solicitud de implementación en torno al comportamiento observable. incluye la restricción que estableció la conversación anterior, pero explica su relevancia para este cambio.

aquí hay un resumen que yo usaría:

1Implementa [comportamiento específico] usando los hallazgos revisados a continuación.
2
3Mantén [comportamiento existente] intacto. Limita las ediciones a [alcance permitido].
4Si el cambio requiere trabajo fuera de ese alcance, explica por qué antes de
5expandirlo.
6
7Verifica las instrucciones actuales del repositorio antes de editar. Verifica
8[resultado esperado] con [prueba relevante o verificación manual], incluyendo
9[caso de fallo importante].
10
11Devuelve un informe conciso de lo que cambió, las verificaciones realmente
12ejecutadas y cualquier limitación no resuelta. No publiques ni despliegues.
13
14Hallazgos revisados:
15[pega los hallazgos que verificaste]

haz que la transferencia sea específica

esos corchetes merecen respuestas reales. "mejorarlo" deja que el agente invente el objetivo. "muestra la exportación fallida con una acción de reintento mientras preservas el error original" les da a ambos algo concreto para inspeccionar.

mantén el hallazgo revisado cerca de la tarea. si la restricción importante está enterrada dentro de una transcripción larga, especifícala en el resumen y adjunta la conversación de respaldo.

la fuente explica de dónde vino la restricción. tu solicitud actual explica cómo gobierna el trabajo de hoy.

4. el ejercicio del proyecto: lleva un error recurrente a través de todo el ciclo

aquí hay un ejercicio hipotético para hacer concreto el flujo de trabajo. imagina que tu proyecto ocasionalmente crea exportaciones duplicadas después de una interrupción de red, y una conversación anterior contiene una investigación sobre el comportamiento de reintento.

1. paso 1: primero, recupera esa conversación. pídele al revisor que identifique lo que estableció la investigación anterior, luego verifica la ruta de reintento actual contra ella.
2. paso 2: supongamos que la discusión anterior dice que las solicitudes pueden repetirse después de una respuesta incierta. el revisor debe establecer si la implementación actual todavía lo permite, qué código lo controla y si ya existe un mecanismo destinado a prevenir duplicados.
3. paso 3: si la evidencia respalda un cambio, instruye al implementador en torno al caso de fallo. especifica qué debería hacer una solicitud repetida, qué comportamiento de exportación existente debe permanecer y cómo verificarás una respuesta interrumpida.
4. paso 4: luego inspecciona el cambio y ejercita la ruta relevante. verifica tanto la exportación exitosa como el reintento después de la incertidumbre. si el entorno no puede reproducir la interrupción, registra esa limitación y decide qué verificación adicional se necesita.
5. paso 5: finalmente, revisa la lección que podrías retener: las condiciones que causaron el duplicado, el mecanismo que lo aborda y la evidencia que respalda la corrección.

este ejemplo es un ejercicio propuesto, no una afirmación sobre un error en agentic stack. sustituye un fallo real de tu propio proyecto y mantén la misma secuencia.

5. la capa compartida: lleva la recuperación a tus otras herramientas

el escritorio puede instalar la integración a través de Tools → Connections → Use @ in tools → Enable in all four tools. el comando equivalente es:

1agentic-stack context install

reinicia las herramientas después. la entrada MCP expone búsqueda de conversaciones, lectura de chat seleccionado y búsqueda de memoria compartida. integración

el comportamiento del selector depende del cliente; donde la finalización de recursos no está disponible, el agente puede buscar y presentar conversaciones coincidentes. comportamiento del cliente

prueba la continuidad entre herramientas

mi primera verificación sería pedirle a otra herramienta que encuentre la misma decisión que acabas de revisar. dale el tema, pídele que presente la fuente coincidente y confirma la selección antes de pedir un análisis.

luego compara el resultado con la fuente que inspeccionaste en el escritorio. estás probando la continuidad del contexto entre herramientas, así que mantén la pregunta estable mientras cambias el lugar donde la haces.

también incluiría la fuente en el resumen final de la tarea cada vez que una decisión afecte materialmente el trabajo. "hablamos de esto antes" le da al agente un problema de búsqueda. "usa esta conversación revisada y verifica esta condición" le da una responsabilidad específica.

6. la capa duradera: lo que merece convertirse en una lección

la recuperación trae material antiguo de vuelta a la vista. todavía tienes que decidir qué autoridad debe tener ese material.

una conversación puede contener un plan abandonado, un diagnóstico incorrecto o una respuesta que era razonable antes de que el proyecto cambiara. preservarlo te permite inspeccionar el razonamiento más tarde; aceptar una lección es una decisión separada.

Tasks contiene registros de ejecución. Knowledge → Lessons admite preparar, aceptar, rechazar y revisitar lecciones con razones, mientras que el historial importado permanece separado de las lecciones aceptadas. ciclo de vida de revisión

escribe una lección que puedas desafiar

yo escribiría una lección propuesta con suficientes detalles para ser desafiada: la condición a la que se aplica, el comportamiento que recomienda, la razón y la evidencia.

para el error de exportación hipotético, "siempre reintentar de forma segura" es demasiado vago para ayudar. una nota útil identifica qué hace que un reintento sea incierto y cómo la implementación de este proyecto debería reconocer el trabajo repetido.

luego pregunta qué haría que la lección quedara obsoleta. un backend diferente, un contrato cambiado o un subsistema reemplazado podrían eliminar la restricción original. incluye ese límite para que la revisión futura tenga por dónde empezar.

así es como mantendría una corrección útil para que no se convierta en una regla que sobreviva a su razón.

6.1 la estructura de la memoria: pon cada tipo de conocimiento en su lugar

debajo del escritorio, la arquitectura portátil .agent/ separa el estado de trabajo, los episodios anteriores, los patrones duraderos y las preferencias personales. skills proporcionan procedimientos reutilizables, mientras que protocols describen permisos y delegación. arquitectura

• la investigación actual pertenece al trabajo en progreso.
• su relato completo se convierte en evidencia de lo que sucedió.
• un patrón verificado puede convertirse en una lección duradera.
• una preferencia sobre cómo quieres que se presenten los resultados pertenece a tus preferencias.

mantener esos significados claros facilita la revisión posterior. una solución temporal debe explicar cuándo se puede eliminar. una preferencia de escritura personal no debe convertirse accidentalmente en una regla arquitectónica.

convierte un procedimiento verificado en un skill

lo mismo se aplica a skills. crearía un skill cuando un procedimiento es lo suficientemente útil para repetirlo y lo suficientemente específico para seguirlo. incluye las entradas que necesita, los pasos que importan, el resultado esperado y las condiciones que requieren otra decisión.

para el ejemplo de exportación, la investigación puede producir un procedimiento útil de verificación de regresión. guárdalo solo después de haber confirmado que los pasos funcionan en tu proyecto. una transcripción copiada le da al próximo agente una historia; un procedimiento revisado le da un método que puedes evaluar.

7. las reglas operativas: breves, acotadas, inspeccionables

aquí están las reglas que pondría alrededor del flujo de trabajo desde el primer proyecto.

1. regla 1: cada resumen nombra el entregable. una revisión devuelve hallazgos con evidencia. una implementación devuelve un cambio de comportamiento con verificaciones. una propuesta de lección devuelve una afirmación que puedes aceptar o rechazar.
2. regla 2: el acceso sigue al trabajo. la investigación comienza con acceso de solo lectura; la implementación obtiene el alcance necesario para el cambio acordado. mantén la publicación, el despliegue y otras acciones consecuentes explícitas en la solicitud.
3. regla 3: pide una verificación real. el informe debe decir qué se ejecutó y qué sucedió. si una verificación no estaba disponible, hazlo visible en lugar de tratar silenciosamente el resultado faltante como un éxito.
4. regla 4: mantén el contexto histórico subordinado a la evidencia actual y las instrucciones aplicables del proyecto. una conversación recuperada puede explicar una decisión anterior y seguir siendo obsoleta.
5. regla 5: revisa el resultado antes de retener la conclusión. la explicación de un agente sobre su propio trabajo es algo para inspeccionar junto con el diff y el comportamiento observado.

estas son prácticas operativas para la configuración que estoy describiendo. ajústalas a tu proyecto, pero mantén las responsabilidades lo suficientemente claras como para que otra persona pueda determinar si una tarea cumplió con su resumen.

7.1 la cola de revisión: haz que el trabajo sea fácil de aceptar o devolver

le pediría a cada implementación que termine en la misma forma:

• qué cambió,
• qué se verificó,
• qué sigue siendo incierto,
• y si propone una lección reutilizable.

eso te da una forma consistente de leer el trabajo completado sin reconstruir toda la conversación cada vez. los detalles de respaldo pueden permanecer disponibles para la parte que necesitas inspeccionar.

cuando devuelvas algo, adjunta la corrección al requisito que no cumplió. "esto está mal" inicia otra ronda de adivinanzas. "el reintento crea una segunda exportación bajo esta condición; preserva la identidad de la solicitud original y vuelve a ejecutar esta verificación" identifica la brecha.

decide qué merece sobrevivir

después de que la corrección pase, decide si representa una restricción recurrente o un detalle de esa tarea. guarda lo primero cuando tenga evidencia detrás. lo segundo puede quedarse en el historial de la tarea.

me resistiría a convertir cada comentario de revisión en memoria permanente. algunas correcciones son útiles una vez. otras revelan una regla que debería dar forma al trabajo posterior. hacer esa distinción es parte del mantenimiento del sistema.

la pregunta útil al final de una revisión es: ¿qué debería saber un agente futuro antes de intentar una tarea similar, y dónde puede verificar ese conocimiento?

7.2 la disciplina de costos: dale a cada ejecución una condición de parada

incluiría una condición de parada en cualquier tarea que pudiera seguir expandiéndose. para una revisión, eso podría ser un informe escrito del comportamiento relevante y las preguntas no resueltas. para la implementación, podría ser el cambio acordado que pasa sus verificaciones nombradas.

si el agente descubre un problema más grande, pídele que explique el hallazgo y su relación con la tarea original antes de absorber ese trabajo en el cambio actual.

decide si esto pertenece a la tarea actual.

compara resultados y aplica límites

elige el ejecutor y el modelo usando las opciones realmente disponibles en tu cuenta, luego evalúalos en tus propios ejemplos acotados. compararía la calidad de los hallazgos, las correcciones requeridas y la verificación entregada antes de hacer que una configuración sea la predeterminada.

mantén el experimento justo manteniendo la tarea y el material fuente estables. si cada prueba cambia la pregunta, el contexto y los criterios de aceptación, la comparación será difícil de interpretar.

y pon los controles de gasto donde sean realmente aplicados por tus herramientas o proveedor. una frase pidiéndole a un agente que sea económico es una preferencia; inspecciona los controles disponibles antes de confiar en un límite.

8. la construcción personalizada: cambia el espacio de trabajo alrededor de un punto de fricción real

una vez que hayas completado el ciclo básico, tendrás una mejor idea de lo que quieres del escritorio en sí. tal vez un paso de navegación repetido te moleste, o una vista de tarea haga que un campo sea más difícil de inspeccionar de lo necesario.

escribe la fricción antes de proponer una característica. describe la acción que estás tratando de realizar, dónde pierdes tiempo y qué te permitiría hacer el comportamiento mejorado.

luego abre el repositorio fuente y dale a tu agente una solicitud de cambio acotada. incluye cómo planeas inspeccionar el resultado en la aplicación.

construye e inspecciona el cambio

el repositorio documenta estos comandos de desarrollo y empaquetado:

1python3 -m pytest -q
2swift build --package-path apps/macos -c release
3python3 scripts/check-desktop-connection.py
4bash scripts/build-macos-app.sh --output ./apps/macos/dist

comandos de desarrollo

los cambios en SwiftUI requieren una reconstrucción y reinicio para inspeccionar. flujo de trabajo del escritorio

probaría la interacción que motivó el cambio y un caso cercano que podría romperse. si mejoras el filtrado de tareas, inspecciona los resultados filtrados, un conjunto de resultados vacío y el camino de regreso a la lista completa.

usa el mismo estándar que aplicaste al ejercicio de exportación: un antes concreto, un cambio acotado y un después observado.

8.1 la opción remota: decide dónde debe vivir el trabajo

después de que el flujo de trabajo local funcione, es posible que desees la ejecución en un servidor persistente. la ruta de autoalojamiento conecta la aplicación nativa a un servicio de un solo propietario que posee sus proyectos, memoria, historial de tareas e inicios de sesión de CLI; cambiar de host no transfiere automáticamente los datos o credenciales de tu Mac. guía de alojamiento

Haría ese movimiento por una razón concreta, como mantener un proyecto y su entorno de ejecución en una máquina que ya administras. Escribe esa razón antes de asumir el trabajo de implementación.

Sigue la guía de alojamiento para la configuración compatible, los pasos de autenticación y verificación. Trata el servidor como otro entorno de trabajo con su propio estado que inspeccionar.

verifica el entorno seleccionado

Luego, repite una tarea familiar allí. Revisa el proyecto seleccionado, confirma que el agente pueda acceder a la fuente prevista y verifica que el resultado pertenezca al entorno del servidor que elegiste.

Usar una tarea conocida facilita evaluar la transición. Si cambias el host, el proyecto y el flujo de trabajo simultáneamente, se vuelve más difícil identificar qué cambio causó un resultado inesperado.

El entorno local es suficiente para aprender el patrón principal. Expande la infraestructura cuando el trabajo te dé una razón.

9. escalar: agrega cobertura donde el ciclo anterior expuso una brecha

Expandiría esta configuración según el contexto faltante que encuentres durante tareas reales.

• Si una revisión necesitaba una discusión de arquitectura anterior, importa esa discusión.
• Si la implementación requería repetidamente el mismo procedimiento, desarrolla y verifica una habilidad.
• Si una decisión se reabre constantemente, escribe una lección delimitada con la evidencia que la respalda.

Mantén una pequeña colección de preguntas cuyas respuestas ya conoces. Úsalas después de cambiar tus importaciones o flujo de trabajo: encuentra esta decisión, explica esta restricción, identifica el código que la implementa y señala la parte que ya no está vigente.

Expande cuando el trabajo lo justifique

Agregaría otro rol de agente solo cuando su responsabilidad esté clara a partir del trabajo. Una revisión recurrente de documentación puede justificar un resumen dedicado. Una solicitud puntual puede encajar perfectamente en un rol existente.

Expande las partes que se han ganado su lugar. Mantén el resto lo suficientemente simple como para entenderlo cuando algo salga mal.

9.1 el hábito de mantenimiento: revisa el conocimiento cuando el sistema cambie

Revisaría las lecciones relevantes cada vez que un subsistema cambie lo suficiente como para alterar sus supuestos. Usa el cambio en sí mismo como detonante: una nueva dependencia, una capa de almacenamiento reemplazada, un entorno de implementación diferente o un requisito de producto revisado.

Pregunta qué lecciones existentes dependen del comportamiento anterior, luego inspecciona esas fuentes junto con el cambio. Conserva lo que aún sea válido, revisa lo que necesite un alcance más limitado y retira lo que ya no aplique a través del flujo de trabajo de revisión disponible.

La parte importante es preservar la explicación. Un futuro constructor debería poder entender por qué existía la regla anterior y qué cambió lo suficiente como para reemplazarla.

Actualiza procedimientos y resuelve conflictos

Para las habilidades, ejecuta el procedimiento nuevamente después de un cambio que afecte sus entradas o comandos. Si un paso ya no funciona, actualiza el procedimiento basándote en el fallo observado y repite la verificación correspondiente.

Esto mantiene el mantenimiento conectado a eventos reales en el proyecto. Estás revisando el conocimiento que probablemente se haya vuelto obsoleto, con evidencia actual ya frente a ti.

Cuando una tarea saque a la luz notas contradictorias, haz que resolver esa contradicción sea parte de la revisión. Identifica qué afirmación aplica a la versión actual y deja el resultado lo suficientemente claro para que el próximo agente pueda seguir el razonamiento sin repetir toda la investigación.

Deja una transferencia útil

Antes de la próxima sesión, deja una breve transferencia que describa el resultado verificado, la pregunta abierta y la fuente que otro agente debería leer primero. Mantenla específica para el estado del proyecto que realmente inspeccionaste.

Eso le da al trabajo de mañana un punto de partida que puedes rastrear, especialmente cuando regreses a través de una herramienta diferente o después de un tiempo, con el razonamiento original aún disponible.

10. la hoja de construcción

1. Elige un repositorio familiar y una decisión que puedas reconocer.
2. Construye el escritorio, completa la configuración e importa una conversación completada que contenga esa decisión.
3. Búscala, inspecciona la fuente y adjúntala a una revisión de solo lectura del código actual.
4. Verifica los hallazgos tú mismo, luego prepara una implementación delimitada con una condición de aceptación visible.
5. Inspecciona el diff y ejecuta la verificación correspondiente, incluyendo el caso de fallo que motivó el trabajo.
6. Prepara una lección solo cuando el resultado lo respalde, con el alcance y la razón registrados.
7. Convierte un procedimiento en una habilidad cuando hayas verificado que vale la pena repetirlo.
8. Intenta la misma recuperación desde otra herramienta, luego expande tu contexto o infraestructura cuando una tarea real lo requiera.

comienza con una decisión esta semana y llévala a través de todo el ciclo antes de importar todo tu historial.

El próximo agente debería heredar tu criterio.