Imagínate esto: son las 11 de la noche de un martes. Estás mirando fijamente un mensaje de error que se siente inquietantemente familiar: Connection refused on port 5432. Ya has estado ahí. Sabes perfectamente que lo resolviste en algún momento, pero... ¿dónde?, ¿cuándo? El mensaje del commit solo dice un vago “fixed db connection”. Stack Overflow te ofrece doce respuestas diferentes y tu asistente de IA te sugiere con entusiasmo soluciones que ya probaste hace una hora.

Esto es la amnesia de la IA en acción, y te está costando bastante más de lo que crees.

Todos los asistentes de programación con IA comparten la misma limitación frustrante: lo olvidan absolutamente todo entre sesiones. Empiezas un nuevo chat y Claude no sabe que ayer pasaste 45 minutos descubriendo que tu entorno de staging usa el puerto 5433, no el 5432. No recuerda que elegiste PostgreSQL en lugar de MongoDB por la experiencia existente de tu equipo. No puede recordar que el error “connection refused” siempre significa que la VPN se desconectó. O, peor aún, empieza a usar una nueva librería de NLP o de gráficos cuando todo el proyecto ya utiliza otra infraestructura y tú ya habías decidido cuál querías. Entonces te ves en la necesidad de explicarlo otra vez. Y otra vez.

¿Todo ese conocimiento ganado con tanto esfuerzo? Desaparece. Cada. Una. De. Las. Veces.

Descubrí una solución sencilla mientras veía un video de YouTube sobre cómo mantener Claude Code actualizado con el contexto del proyecto. El creador enlazaba pequeños archivos Markdown desde su CLAUDE.md para hacer un seguimiento impecable de decisiones, bugs y datos clave. En ese instante tuve un momento de total claridad: ¿y si pudiera crear una skill que gestionara esto de forma automática?

Esa idea se convirtió en project-memory, una de las primeras skills que escribí para Claude Code. A pesar de ser notablemente simple —menos de 300 líneas—, de verdad me ha ahorrado horas y horas de trabajo. Este tutorial te muestra cómo construir tu propia skill de memoria de proyecto y, lo que es aún más importante, cómo pensar en la creación de skills diseñadas para resolver problemas reales.

Es importante destacar que Claude Code ya no es el único jugador en el tablero. Codex, GitHub Copilot y OpenCode han anunciado soporte para Agentic Skills. Incluso existe ya un marketplace de agentic skills compatible con Gemini, Aidr, Qwen Code, Kimi K2 Code, Cursor y más; sumando más de 14 plataformas y contando, con un instalador universal de agentic skills (skilz). A lo largo de esta guía, usaré “Claude” y “agente de programación” de forma intercambiable, tal como cuando decimos “hazme un Xerox” en lugar de “sácame una copia”. Para lo que vale, en mis propios flujos de trabajo prefiero Claude Code, OpenCode y Gemini CLI.

El verdadero coste de la amnesia de la IA

Déjame pintarte una escena que quizás reconozcas a la perfección:

Mes 1: El descubrimiento

  • Error: CORS policy blocked request from localhost:3000
  • Acción: 2 horas depurando, probando configuraciones de proxy, cambios de headers y reescrituras en nginx.
  • Solución: Añadir la configuración de proxy a package.json.

Mes 6: El déjà vu

  • Error: CORS policy blocked request from localhost:3000
  • Desarrollador: "Esto me suena... ¿cómo lo arreglamos aquella vez?"
  • Acción: Busca commits antiguos, revisa Stack Overflow otra vez, le pregunta a Claude (que no tiene memoria).
  • Resultado: 1 hora para redescubrir exactamente la misma solución de configuración de proxy.

¿Te suena familiar? Aquí está la verdad incómoda: los asistentes de código con IA en realidad empeoran esta situación en lugar de mejorarla. Sin memoria:

  • Cada nueva sesión de chat empieza desde cero conocimiento.
  • Cada bug se siente como si lo estuvieras resolviendo por primera vez.
  • Las soluciones se “redescubren” repetidamente —en una ocasión resolví el mismo problema de CORS cuatro veces en seis meses—.
  • No se acumula aprendizaje con el tiempo, ni para ti ni para tu asistente de IA.

El coste oculto es enorme. Si gastas tan solo 30 minutos por semana resolviendo otra vez problemas que ya habías solucionado, estamos hablando de 26 horas al año. A una tasa estimada de 100 dólares por hora, representan 2.600 dólares de tiempo desperdiciado por cada desarrollador.

Pero... ¿y si tu asistente de IA pudiera recordar?

¿Qué es una Agent Skill de Claude Code?

Antes de adentrarnos en project-memory, entendamos qué son realmente las skills. Si alguna vez has querido enseñarle a Claude un flujo de trabajo específico o darle conocimiento profundo de un dominio, las skills son la respuesta ideal.

Una agent skill es simplemente una carpeta que contiene un archivo SKILL.md y recursos de apoyo opcionales. El archivo SKILL.md consta de dos partes esenciales:

  1. YAML frontmatter: Metadatos que le dicen a Claude exactamente cuándo activar la skill.
  2. Cuerpo en Markdown: Las instrucciones detalladas que Claude sigue cuando la skill está activa.

Piensa en las skills como “modos expertos” reutilizables que puedes instalar. Cuando indicas “configura la memoria del proyecto”, Claude no se limita a adivinar qué quieres decir; carga instrucciones específicas y probadas minuciosamente para esa tarea.

Anatomía de la estructura de una Agent Skill

Estructura del archivo SKILL.md mostrando YAML frontmatter con nombre y descripción, y cuerpo en Markdown con secciones para Overview, When to Use, Core Capabilities, Examples y Success Criteria.

Las skills normalmente pueden vivir en dos ubicaciones estratégicas:

Guarda skills en tu directorio home de usuario ~/.claude/skills/. Estas están disponibles globalmente en todos los proyectos y son para skills de propósito general como revisión de código o documentación. Luego puedes tener skills específicas de proyecto que viven en .claude/skills/. Estas son locales solo para ese proyecto: flujos de trabajo específicos del proyecto y convenciones del equipo. Digo normalmente porque puedes tener skills empresariales, skills compartidas a nivel de monorepo, etc. Y también depende de qué proveedor estés usando: ~/.codex/skills/, ~/.config/opencode/skill/, ~/.gemini/skills/, .claude/skills/, .codex/skills/, .opencode/skills/, solo por nombrar algunas.

💡 Un pequeño truco: ejecuta ls ~/.claude/skills/ para ver qué herramientas tienes ya instaladas. Si el directorio todavía no existe, se creará de forma automática cuando instales tu primera skill.

Cómo funciona la activación de skills

Cuando haces una petición, Claude Code sigue un patrón de revelación progresiva para escribir agentic skills. Solo carga lo que necesita, en el momento preciso en que lo necesita. Esto mantiene las interacciones sumamente rápidas mientras te da acceso a capacidades potentes bajo demanda.

Diagrama de flujo de activación de skills que muestra tres fases: Discovery —escanear directorios, cargar metadatos—, Matching —comprobar si la petición coincide con una skill— y Execution —cargar SKILL.md, seguir instrucciones, completar la tarea—.

La idea clave es hermosa por su eficiencia: Claude escanea los directorios de skills y lee únicamente los metadatos —nombre y descripción— hasta que encuentra una coincidencia. Solo en ese momento carga las instrucciones completas. Esto significa que puedes tener decenas de skills instaladas sin ralentizar en lo absoluto tus interacciones habituales.

Ahora que comprendemos la mecánica, veamos cómo project-memory la pone en práctica.

La Agent Skill de Project Memory

La skill project-memory crea un sistema de conocimiento estructurado dentro de docs/project_notes/ con cuatro archivos especializados. Cada uno cumple un propósito muy claro para preservar y recuperar el conocimiento del proyecto.

Estructura de archivos de memoria

Estructura de archivos de memoria de proyecto que muestra la carpeta docs/project_notes/ con bugs.md, decisions.md, key_facts.md e issues.md, además de los archivos de configuración CLAUDE.md y AGENTS.md.
Cada archivo de memoria cumple un rol específico en la captura de conocimiento del proyecto. Por ejemplo, bugs.md actúa como una base de datos de bugs buscable, donde entradas como “BUG-018: Pulumi state drift — run pulumi refresh — yes” documentan tanto el problema como su solución, evitando pérdidas de tiempo futuras cuando el mismo problema reaparece. Uso esto para hacer seguimiento de problemas recurrentes del proyecto. El archivo decisions.md rastrea elecciones arquitectónicas mediante ADRs —Architectural Decision Records—, como “ADR-012: Use D3.js for all charts (team expertise)”, asegurando consistencia y evitando decisiones tecnológicas conflictivas más adelante. Mientras tanto, key_facts.md sirve como referencia rápida para detalles esenciales del proyecto como “Staging API: https://api.staging.example.com:8443”, eliminando las conjeturas sobre puertos y URLs. Por último, issues.md mantiene un registro cronológico de trabajo con entradas como “TICKET-456: Implemented user auth — 2024-01-15”, creando una pista de auditoría que conecta el trabajo completado con tickets y fechas específicos.

Permíteme desglosar cómo funciona minuciosamente cada sección de esta skill.

Parte 1: El frontmatter de la Agent Skill —el “cuándo” de tu skill—

YAML

---
name: project-memory
description: Set up and maintain a structured project memory system in docs/project_notes/
  that tracks bugs with solutions, architectural decisions, key project facts, and work
  history. Use this skill when asked to "set up project memory", "track our decisions",
  "log a bug fix", "update project memory", or "initialize memory system".
---

El campo description es absolutamente crítico; me atrevería a decir que es la parte más importante de tu skill. Le indica a Claude con precisión cuándo activarla. Fíjate en las frases específicas de activación incluidas: “set up project memory”, “track our decisions”, “log a bug fix”. Cuando pronuncias cualquiera de estas, Claude reconoce la coincidencia y despliega las instrucciones completas (puedes ver la skill completa al final del artículo).

💡 Una recomendación de diseño: cuando escribas tus propias descripciones de skills, incluye de 3 a 5 frases específicas que usarías de forma natural en el día a día. Prueba la activación con variaciones como: “help me track decisions” vs “set up decision tracking” vs “I want to log our architectural choices”.

Parte 2: Cuándo usar esta Agent Skill —disparadores contextuales—

Markdown

## When to Use This Skill

Invoke this skill when:
- Starting a new project that will accumulate knowledge over time
- The project already has recurring bugs or decisions that should be documented
- The user asks to "set up project memory" or "track our decisions"
- Encountering a problem that feels familiar ("didn't we solve this before?")
- Before proposing an architectural change (check existing decisions first)

Esta sección refuerza los disparadores y ayuda a Claude a comprender el contexto más amplio en el que la memoria resulta verdaderamente útil. La frase “¿no resolvimos esto antes?” es especialmente poderosa, pues captura el momento exacto de frustración donde la memoria llega al rescate.

Parte 3: Instrucciones de configuración inicial —el “qué” de tu Agent Skill—

Markdown

## Core Capabilities

### 1. Initial Setup - Create Memory Infrastructure

When invoked for the first time in a project, create the following structure:

docs/
└── project_notes/
    ├── bugs.md         # Bug log with solutions
    ├── decisions.md    # Architectural Decision Records
    ├── key_facts.md    # Project configuration and constants
    └── issues.md       # Work log with ticket references

**Directory naming rationale:** Using `docs/project_notes/` instead of `memory/`
makes it look like standard engineering organization, not AI-specific tooling.

Esta decisión de diseño es más profunda de lo que parece a simple vista: haz que la memoria luzca como documentación normal. Si creas archivos en carpetas como ai-memory/ o claude-context/, el equipo de desarrollo tenderá a verlo como un simple accesorio de la IA y terminará ignorándolo. En cambio, guardarlo en docs/project_notes/ le da el estatus de documentación estándar de ingeniería que cualquiera puede —y debe— actualizar, use o no asistencia de IA.

Parte 4: Formatos de entradas de memoria —conocimiento estructurado—

La skill define formatos consistentes para cada tipo de entrada. La consistencia es clave porque Claude puede analizar formatos estructurados de forma sumamente fiable, incluso meses después:

Comparación lado a lado del formato de entrada de bugs.md —Issue, Root Cause, Solution, Prevention— y el formato ADR de decisions.md —Context, Decision, Alternatives, Consequences—.

El campo Prevention en el registro de bugs es un verdadero tesoro. Transforma los problemas cotidianos de simples “cosas que arreglamos” a “lecciones que aprendimos”. Así, dentro de seis meses, Claude podrá advertirte elegantemente antes de que vuelvas a caer en la misma trampa.

Parte 5: Protocolos de memoria para CLAUDE.md —la verdadera magia—

Aquí es donde reside el verdadero poder. La skill configura tu CLAUDE.md para que el asistente sea consciente de la memoria por defecto:

Markdown

### 2. Configure CLAUDE.md - Memory-Aware Behavior

Add or update the following section in the project's `CLAUDE.md` file:

## Project Memory System

### Memory-Aware Protocols

**Before proposing architectural changes:**
- Check `docs/project_notes/decisions.md` for existing decisions
- Verify the proposed approach doesn't conflict with past choices

**When encountering errors or bugs:**
- Search `docs/project_notes/bugs.md` for similar issues
- Apply known solutions if found
- Document new bugs and solutions when resolved

**When looking up project configuration:**
- Check `docs/project_notes/key_facts.md` for credentials, ports, URLs
- Prefer documented facts over assumptions

Una vez que estos protocolos quedan establecidos en CLAUDE.md, Claude revisará de manera automática los archivos de memoria antes de tomar decisiones o sugerirte código. Ya no tendrás que acordarte de decirle "revisa el registro de bugs"; se convierte, de forma orgánica, en su comportamiento por defecto.

Impacto en el mundo real: el interés compuesto del conocimiento

Déjame compartir contigo algunos ejemplos muy concretos de cómo la memoria transforma nuestros flujos de trabajo cotidianos.

Resolución de bugs con memoria

Diagrama comparativo que muestra la resolución de bugs sin memoria —45 minutos depurando desde cero— frente a con memoria —5 minutos buscando una solución conocida en bugs.md—.

Personalmente he desperdiciado demasiadas horas persiguiendo problemas que ya había visto en el pasado, por lo que estimar 45 minutos se queda bastante corto frente al ahorro potencial real. Y no es solo el tiempo; es la frustración que te ahorras.

Ejemplo 1: Velocidad de resolución de bugs —números reales—

El escenario real fue el siguiente: El 20 de octubre me encontré con un error de desviación de estado de Pulumi durante un despliegue. El mensaje de error era bastante críptico: error: update failed. Tras 45 minutos de intensa depuración revisando permisos IAM, cambios recientes y probando diferentes estrategias, descubrí la solución: ejecutar pulumi refresh --yes para sincronizar el archivo de estado.

Lo documentamos de inmediato como BUG-018:

Markdown

### 2024-10-20 - BUG-018: Pulumi State Drift During Deploy

**Issue**: Deploy failed with cryptic "update failed" error after manual GCP console changes
**Root Cause**: Pulumi state file out of sync with actual infrastructure after teammate made console changes
**Solution**: Run `pulumi refresh --yes` before deploy to sync state
**Prevention**: Add `pulumi refresh --yes` to CI/CD pipeline before deploys; document that manual console changes require refresh

Tan solo dos días después, el 22 de octubre, volvió a aparecer exactamente el mismo error. Esta vez, el flujo fue una seda:

  1. Le comenté a Claude la situación del error.
  2. Claude revisó ágilmente bugs.md y localizó el registro BUG-018.
  3. Me sugirió de inmediato ejecutar pulumi refresh --yes.
  4. Problema resuelto en solo 5 minutos.

El resultado: Redujimos el tiempo de 45 a solo 5 minutos. Una espectacular reducción del 89% en el tiempo de resolución.

Ejemplo 2: Consistencia arquitectónica —evitando el aumento del bundle—

Sin memoria:

  • Usuario: "Añade un gráfico de barras al dashboard."
  • Claude: "Perfecto, añadiré Chart.js para el gráfico de barras. Déjame instalarlo..."
  • Resultado: Tamaño del bundle +85 KB, dependencias duplicadas para gráficos y estilos inconsistentes.

Con memoria:

  • Usuario: "Añade un gráfico de barras al dashboard."
  • Claude: (Revisando silenciosamente decisions.md...) "Veo que en el ADR-012 decidimos usar D3.js para todos los gráficos dado que el equipo tiene experiencia en ella y ya se encuentra en el bundle. Crearé el gráfico de barras usando D3 para mantener la consistencia."
  • Resultado: Reutilización de la infraestructura existente, estilo impecable y cero aumento innecesario del bundle.

Esta clase de consistencia se acumula de manera hermosa. Una sola decisión bien documentada sobre una librería te evita docenas de conflictos de dependencias en el futuro.

El efecto del interés compuesto

Línea de tiempo de interés compuesto del conocimiento que muestra la progresión desde el primer encuentro —2 horas depurando—, a la documentación, al segundo encuentro —5 minutos—, al tercero —2 minutos—, hasta el consejo preventivo.

La captura de conocimiento devuelve beneficios con un interés compuesto asombroso. Observa la progresión en el diagrama: para el cuarto encuentro, Claude no solo arregla el bug, sino que lo previene: “Veo que estás a punto de hacer un cambio que antes causó problemas de desviación de estado. ¿Te gustaría que ejecute pulumi refresh primero?”

Tu proyecto se vuelve sustancialmente más fácil de mantener con el tiempo. Ese es el verdadero valor de la persistencia de contexto.

Multiplataforma: el estándar Agent Skill

Aquí viene una de las características más potentes: project-memory no está limitada en exclusiva a Claude Code. Sigue el estándar abierto Agent Skill Standard (agentskills.io), lo que significa que la misma skill funciona a la perfección en más de 14 asistentes de programación con IA. También incluye instrucciones nativas para mantener actualizado tu archivo AGENTS.md.

¿Por qué es esto tan valioso? En los equipos es normal que coexistan diferentes herramientas. Un desarrollador puede adorar Claude Code, otra prefiere Cursor y un tercero se siente más cómodo con GitHub Copilot. Con skills estandarizadas, absolutamente todo el equipo comparte la misma memoria central del proyecto.

Diagrama que muestra cómo Agent Skill Standard permite que una skill funcione en Claude Code, Codex, Gemini, Cursor y más.

Instalación multiplataforma

Diagrama de instalación de skills multiplataforma que muestra GitHub y el marketplace SkillzWave como fuentes, la CLI skilz como instalador, distribuyendo a Claude Code, Codex, Gemini, Cursor, Copilot y más agentes de IA.

Gracias a que las agent skills se han vuelto maravillosamente multiplataforma, podemos usar instaladores universales muy cómodos. Puedes obtenerlas desde GitHub o desde el marketplace de agentes SkillzWave utilizando la CLI open source skilz:

Bash

# Instalación de la CLI
pip install skilz

# Instalar para Claude Code de forma global (disponible en todos tus proyectos)
skilz install -g https://github.com/SpillwaveSolutions/project-memory

# Instalar exclusivamente para un proyecto específico
skilz install -g https://github.com/SpillwaveSolutions/project-memory --project

# Instalar para otros asistentes del equipo
skilz install -g https://github.com/SpillwaveSolutions/project-memory --agent codex
skilz install -g https://github.com/SpillwaveSolutions/project-memory --agent gemini
skilz install -g https://github.com/SpillwaveSolutions/project-memory --agent cursor
skilz install -g https://github.com/SpillwaveSolutions/project-memory --agent opencode

El mismo conocimiento, perfectamente accesible desde cualquier herramienta que decidas usar. Cuando documentas una solución en Claude Code, tu compañera que usa Cursor o Gemini se beneficiará de ese valioso contexto al día siguiente.

Visualización de project-memory en el marketplace Skillz con instrucciones de instalación para varias plataformas de agentes de programación.

Seguridad: lo que jamás debes guardar

Esta sección es de lectura obligatoria y crítica antes de que comiences a utilizar la memoria del proyecto.

El archivo key_facts.md está diseñado para ser una consulta sumamente cómoda de la configuración de tu proyecto. Sin embargo, sabemos que la comodidad a veces coquetea con el riesgo si bajamos la guardia. Nunca guardes secretos en tus archivos de memoria. Recuerda que son archivos Markdown versionados que cualquiera con acceso al repositorio de Git podrá leer.

🚫 La zona de peligro (Nunca lo guardes aquí)

  • Credenciales de autenticación: Contraseñas, claves de API, tokens de acceso o secretos personales.
  • Claves de cuentas de servicio: Archivos JSON de GCP/AWS, claves privadas o credenciales de cuentas de servicio.
  • Secretos OAuth: Secretos de cliente, refresh tokens o configuraciones de aplicaciones.
  • Credenciales de bases de datos: Cadenas de conexión que expongan contraseñas explícitas.
  • Secretos de infraestructura: Claves SSH privadas, accesos de VPN o credenciales de red.

La zona segura (Totalmente bienvenido)

  • Hostnames y URLs: Dominios públicos o de desarrollo como api.staging.example.com o https://api.example.com/v1.
  • Números de puerto: Estándares como PostgreSQL (5432) o Redis (6379).
  • Identificadores de proyecto: IDs de proyectos en GCP, cuentas de AWS o nombres similares que no sean sensibles.
  • Correos de cuentas de servicio: Identidades como service-account@project.iam.gserviceaccount.com.
  • Nombres de entornos: Etiquetas claras como staging, production o dev.
  • Endpoints públicos: Cualquier URL de API accesible.
  • Valores de configuración: Ajustes de timeouts, reintentos o feature flags.

🔑 Dónde deben vivir realmente los secretos

  • Archivos .env (siempre incluidos en tu .gitignore): Lo ideal para desarrollo local (DATABASE_PASSWORD=secret123).
  • Gestores de secretos en la nube: Para producción siempre debemos apoyarnos en herramientas como GCP Secret Manager, AWS Secrets Manager o Azure Key Vault.
  • Variables de CI/CD: Configuraciones protegidas en GitHub Actions, GitLab CI/CD, etc.
  • Gestores de contraseñas de equipo: Espacios compartidos y seguros como 1Password, LastPass o Bitwarden.

💡 Una pequeña tarea proactiva: tómate dos minutos para buscar en tu estructura actual términos como password, secret, key o token. Si encuentras algo comprometido, muévelo de inmediato a un lugar seguro y rota las credenciales. Vivimos en una sociedad civilizada y tenemos reglas de seguridad. :)

Errores comunes —y cómo evitamos caer en ellos—

Después de implementar project-memory en docenas de proyectos y guiar a muchos equipos en su adopción, he notado ciertos patrones de tropiezos comunes. Te los comparto para que puedas saltártelos:

Error 1: El pueblo fantasma de la documentación

  • El problema: Instalas el sistema con muchísimo entusiasmo, creas tres entradas iniciales y no lo vuelves a tocar. Meses después, los archivos están obsoletos y ya no sirven.
  • La solución: Integra las actualizaciones de memoria de forma orgánica en tu flujo de trabajo diario, no en tu lista de pendientes pendientes. Al resolver un bug, dile a Claude: “Registra esto en bugs.md”. Al cerrar una discusión técnica: “Añade un ADR para esta decisión”. Hazlo un reflejo intuitivo.
  • Nota avanzada: He desarrollado también una skill avanzada que divide las tareas entre un agente arquitecto, un agente de código y un humano al mando. Esta herramienta instala un hook en Claude o un plugin en OpenCode que escanea automáticamente los logs en segundo plano buscando patrones de decisiones, bugs o datos clave que se te hayan pasado registrar, automatizando el mantenimiento.

Error 2: La entrada del tamaño de una novela

  • El problema: Las notas de bugs se transforman en extensos ensayos de varias páginas y los ADRs detallan cada pequeña discusión del canal de Slack. Nadie los lee porque consumen demasiado tiempo.
  • La solución: Cada entrada debe poder escanearse con la mirada en menos de 30 segundos. Apóyate de forma estricta en el formato estructurado (Issue, Root Cause, Solution, Prevention). Si necesitas profundizar, simplemente añade un enlace a un documento independiente.

Error 3: El archivo para todo

  • El problema: Toda la información comienza a acumularse en key_facts.md hasta volverlo un monolito ilegible de 500 líneas.
  • La solución: Respeta el propósito de cada uno de los cuatro archivos: los bugs van en bugs.md, las decisiones arquitectónicas en decisions.md, las configuraciones limpias en key_facts.md y el historial en issues.md. Si el archivo de datos clave supera las 100 líneas, es muy probable que estés camuflando decisiones de diseño como simples datos.

Error 4: La trampa del déjà vu

  • El problema: Te topas con ese instante frustrante de: "Yo sé que ya vi este error antes, sé que lo solucionamos, pero no recuerdo cómo", y terminas gastando media hora redescubriendo el hilo negro.
  • La solución: Esto es precisamente lo que este sistema viene a erradicar. Ante la menor sensación de familiaridad, tu primer comando debe ser: “Revisa el archivo bugs.md”. El conocimiento tribal o institucional del equipo queda así plasmado al alcance de una consulta rápida, facilitando enormemente el onboarding de nuevos integrantes.

Construyendo tus propias Agent Skills

La skill project-memory es un excelente lienzo que demuestra principios fundamentales de diseño que puedes aplicar a cualquier herramienta que decidas programar en el futuro:

  1. Resuelve un punto de dolor real: Comienza a diseñar skills solo cuando notes que te repites demasiado explicándole el mismo contexto a Claude, buscando la misma información una y otra vez, o deseando fervientemente que la IA "simplemente supiera" un detalle de tu arquitectura. Antipatrón: No construyas soluciones para problemas hipotéticos; si no has sentido la frustración del problema, difícilmente darás con la ergonomía de la solución.
  2. Mantén un enfoque único (Una skill = Un propósito): Evita la tentación de concebir una "super skill" monolítica. Las herramientas pequeñas y modulares son infinitamente más mantenibles. project-memory gestiona contexto; code-review analiza calidad. Manténlo así de limpio.
  3. Diseña disparadores naturales: Añade descripciones conversacionales que usarías de forma cotidiana al hablar con tu asistente ("log this bug", "update key facts"). Evita tecnicismos innecesarios como "initialize documentation subsystem".
  4. Usa plantillas visuales claras: Claude responde de manera mucho más fiel ante ejemplos visuales estructurados que ante instrucciones abstractas en prosa. Bríndale siempre una estructura de ejemplo limpia.

Pruébalo tú misma

¿Lista para añadir persistencia de memoria a tus flujos de trabajo? Puedes dejarlo todo listo en menos de cinco minutos siguiendo este inicio rápido:

Bash

# Instala la CLI universal
pip install skilz

# Instala la skill de project-memory de manera global
skilz install https://github.com/SpillwaveSolutions/project-memory

Luego, simplemente abre Claude Code en cualquiera de tus repositorios y dile de manera natural:

"Set up project memory for this project"

Claude se encargará de desplegar toda la infraestructura en docs/, configurar los protocolos en tu CLAUDE.md y dejar el entorno listo para usar. Si deseas ser ultra específica, también puedes indicarle:

"Set up project memory for this project using the project memory skill"O directamente invocarla con: "/project-memory-skill Set up project memory for this project"

La herramienta está diseñada para actualizar tanto CLAUDE.md como AGENTS.md de forma nativa, ya que suelo alternar bastante entre Claude Code y OpenCode en mis flujos diarios de ingeniería.

El reto de tu primera semana

No intentes documentar todo el historial de tu empresa el primer día. Te sugiero un acercamiento gradual y elegante:

  • Día 1: Configura la infraestructura de memoria de tu proyecto.
  • Día 2: Añade un dato clave a key_facts.md (ese puerto o URL que siempre olvidas).
  • Día 3: Registra un bug real en bugs.md inmediatamente después de solucionarlo.
  • Día 4: Redacta un pequeño registro de decisión arquitectónica (ADR) en decisions.md.
  • Día 5: Pon a prueba el sistema. Pregúntale a Claude sobre el contexto que guardaste en los días previos.

Para el quinto día experimentarás ese maravilloso momento de revelación cuando Claude recuerde con total precisión un detalle que conversaron a inicios de la semana. Ahí es cuando el valor se vuelve tangible.

Ideas de evolución: haciendo la memoria aún mejor

Aunque la estructura actual resuelve de forma brillante el problema central, siempre hay espacio para la sofisticación y la mejora incremental:

  1. Generación automática de Tabla de Contenidos: A medida que los archivos crecen más allá de las 50 o 100 entradas, la navegación estructurada se vuelve vital tanto para los desarrolladores humanos como para las búsquedas semánticas de la IA. Implementar una sección de índices dinámicos al inicio de los Markdown agiliza enormemente el descubrimiento parcial de información.
  2. Archivado automatizado de registros históricos: Un bug solucionado hace dos años puede generar ruido innecesario en la ventana de contexto actual. Mover de forma automática las entradas antiguas de bugs.md o issues.md hacia archivos históricos como bugs-archive-2025.md mantendrá tu memoria principal ligera, limpia y optimizada. (Nota: los ADRs y los datos clave no se archivan, pues su valor histórico permanece intacto).
  3. Detección inteligente multiagente: Hacer que la skill detecte de forma proactiva qué asistentes conviven en el repositorio y configure simultáneamente archivos como CLAUDE.md, GEMINI.md o AGENT.md según las necesidades exactas del equipo.

La belleza de este sistema modular de skills es que nos permite añadir toda esta sofisticación de manera progresiva y sin romper la funcionalidad que ya está operando hoy.

Conclusión: empieza pequeño, acumula rápido

La skill project-memory es intencionadamente minimalista: una carpeta bien estructurada con un SKILL.md y un puñado de plantillas que no superan las 300 líneas en su totalidad. Sin embargo, representa una inversión de altísimo retorno que te ahorrará docenas de horas al eliminar depuraciones redundantes, asegurar la consistencia del diseño arquitectónico y blindar el conocimiento de tu equipo frente a los reinicios de sesión.

A veces, un archivo Markdown estructurado con elegancia y unos protocolos de equipo claros valen más que la automatización más compleja del mercado.

Te extiendo el reto: instala project-memory hoy mismo. Documenta una sola decisión, un bug y una URL esta semana. Descubre el placer de trabajar con una IA que finalmente posee memoria. Tu yo del futuro, esa que no tendrá que solucionar el mismo problema de CORS por quinta vez, te lo agradecerá enormemente.

Recursos útiles

  • Project Memory Agent Skill en GitHub: Accede al código fuente completo y ejemplos prácticos.
  • Project Memory Agent Skill en el Marketplace de SkillzWave: Instrucciones detalladas de instalación.
  • Agent Skill Standard: Especificaciones formales del estándar multiplataforma.
  • SkillzWave Marketplace: Explora e instala soluciones diseñadas por la comunidad.
  • Repositorio de la CLI skilz: Guías de uso, instalación y código fuente del instalador universal.

¿Has construido alguna skill interesante para solucionar algún dolor de cabeza en tus desarrollos? Me encantaría leerte en los comentarios y conocer lo que estás creando.

#AI #Claude #ClaudeCode #DeveloperTools #Productivity #SoftwareDevelopment #Programming #AICodingAssistant #DevOps #TechTutorial #CodingTips #AITools

Sobre el autor

Rick Hightower es un ejecutivo tecnológico e ingeniero de datos con una trayectoria distinguida liderando el desarrollo de soluciones avanzadas de Machine Learning e Inteligencia Artificial dentro de organizaciones financieras de la lista Fortune 100. Su experiencia equilibra la rigurosidad de los frameworks teóricos con la implementación práctica a escala empresarial.

Rick es el creador de la CLI universal de instalación skilz —compatible con Gemini, Claude Code, Codex y Cursor, entre otros— y cofundador del mayor marketplace de agentic skills a nivel global. Puedes conectar con él a través de sus perfiles profesionales en LinkedIn o Medium para profundizar en estrategias de IA empresarial.

Extensiones y recursos de la comunidad

La comunidad activa alrededor de Claude Code ha diseñado un ecosistema de extensiones sumamente potentes. Te comparto algunas de las soluciones más destacadas desarrolladas por Spillwave Solutions:

Skills de Integración Empresarial

  • Notion Uploader/Downloader Agent Skill: Sincroniza contenido Markdown e imágenes directamente con tus espacios de Notion.
  • Confluence Agent Skill: Sube y descarga documentación técnica con Confluence de forma transparente.
  • JIRA Integration Agent Skill: Creación, lectura y gestión avanzada de tickets de JIRA manejando de forma precisa los campos requeridos.
  • Nota: Recientemente diseñé una aplicación de escritorio llamada Agent Skill Viewer, ideal para evaluar la seguridad, enlaces y utilidad de tus herramientas de automatización.

Agentes de Desarrollo Avanzado

  • Architect Agent Skill: Eleva Claude Code a un "Modo Arquitecto", permitiéndole coordinar múltiples proyectos y delegar subtareas de desarrollo a otras instancias especializadas de la IA.
  • Project Memory Agent Skill: Nuestra solución central para preservar datos críticos, bugs y decisiones arquitectónicas entre sesiones de ingeniería de software.

Visualización y Diseño Técnico

  • Design Doc Mermaid Agent Skill: Diseñada especialmente para concebir diagramas de flujo y secuencias Mermaid con acabado profesional para tus documentaciones.
  • PlantUML Agent Skill: Genera y extrae diagramas PlantUML directamente desde tu código fuente o archivos Markdown.
  • Image Generation Agent Skill: Conexión nativa con Gemini Banana para la creación de assets de diseño e imágenes de documentación.
  • SDD Agent Skill: Una guía completa para implementar la metodología de desarrollo guiado por especificaciones (Spec-Driven Development) usando el Spec-Kit de GitHub.
  • PR Reviewer Agent Skill: Automatiza por completo la revisión de Pull Requests en GitHub integrando la CLI gh. Analiza criterios de seguridad, cobertura de pruebas y mantenibilidad según los estándares de la industria, generando feedback estructurado listo para aprobación.

Integración de Modelos

  • Gemini Agent Skill: Permite delegar de forma elegante tareas específicas hacia los modelos multimodales de Google para flujos colaborativos de IA.

Puedes explorar todo el catálogo de soluciones a medida y automatizaciones impulsadas por IA visitando la página principal de Spillwave Solutions. Encontrarás un sinfín de artículos sobre context engineering y arquitectura en mi blog personal. ¡Asegúrate de seguirme en Medium para no perderte ninguna actualización!

Archivo Markdown completo de la skill

Markdown

---
name: project-memory
description: Set up and maintain a structured project memory system in docs/project_notes/ that tracks bugs with solutions, architectural decisions, key project facts, and work history. Use this skill when asked to "set up project memory", "track our decisions", "log a bug fix", "update project memory", or "initialize memory system". Configures both CLAUDE.md and AGENTS.md to maintain memory awareness across different AI coding tools.
---

# Project Memory
 
## Table of Contents

- [Overview](#overview)
- [When to Use This Skill](#when-to-use-this-skill)
- [Core Capabilities](#core-capabilities)
  - [1. Initial Setup - Create Memory Infrastructure](#1-initial-setup---create-memory-infrastructure)
  - [2. Configure CLAUDE.md - Memory-Aware Behavior](#2-configure-claudemd---memory-aware-behavior)
  - [3. Configure AGENTS.md - Multi-Tool Support](#3-configure-agentsmd---multi-tool-support)
  - [4. Searching Memory Files](#4-searching-memory-files)
  - [5. Updating Memory Files](#5-updating-memory-files)
  - [6. Memory File Maintenance](#6-memory-file-maintenance)
- [Templates and References](#templates-and-references)
- [Example Workflows](#example-workflows)
- [Integration with Other Skills](#integration-with-other-skills)
- [Success Criteria](#success-criteria)

## Overview

Maintain institutional knowledge for projects by establishing a structured memory system in `docs/project_notes/`. This skill sets up four key memory files (bugs, decisions, key facts, issues) and configures CLAUDE.md and AGENTS.md to automatically reference and maintain them. The result is a project that remembers past decisions, solutions to problems, and important configuration details across coding sessions and across different AI tools.

## When to Use This Skill

Invoke this skill when:

- Starting a new project that will accumulate knowledge over time
- The project already has recurring bugs or decisions that should be documented
- The user asks to "set up project memory" or "track our decisions"
- The user wants to log a bug fix, architectural decision, or completed work
- Encountering a problem that feels familiar ("didn't we solve this before?")
- Before proposing an architectural change (check existing decisions first)
- Working on projects with multiple developers or AI tools (Claude Code, Cursor, etc.)

## Core Capabilities

### 1. Initial Setup - Create Memory Infrastructure

When invoked for the first time in a project, create the following structure:

docs/
└── project_notes/
    ├── bugs.md         # Bug log with solutions
    ├── decisions.md    # Architectural Decision Records
    ├── key_facts.md    # Project configuration and constants
    └── issues.md       # Work log with ticket references

Motivo del nombre del directorio: usar docs/project_notes/ en lugar de memory/ hace que parezca una organización estándar de ingeniería, no tooling específico de IA. Esto aumenta la adopción y el mantenimiento por parte de desarrolladores humanos.

Contenido inicial de archivos: copia las plantillas del directorio references/ de esta skill:
- Usa references/bugs_template.md para el bugs.md inicial.
- Usa references/decisions_template.md para el decisions.md inicial.
- Usa references/key_facts_template.md para el key_facts.md inicial.
- Usa references/issues_template.md para el issues.md inicial.
Cada plantilla incluye ejemplos de formato y consejos de uso.

### 2. Configure CLAUDE.md - Memory-Aware Behavior

Add or update the following section in the project's `CLAUDE.md` file:

## Project Memory System

This project maintains institutional knowledge in `docs/project_notes/` for consistency across sessions.

### Memory Files

- **bugs.md** - Bug log with dates, solutions, and prevention notes
- **decisions.md** - Architectural Decision Records (ADRs) with context and trade-offs
- **key_facts.md** - Project configuration, credentials, ports, important URLs
- **issues.md** - Work log with ticket IDs, descriptions, and URLs

### Memory-Aware Protocols

**Before proposing architectural changes:**
- Check `docs/project_notes/decisions.md` for existing decisions
- Verify the proposed approach doesn't conflict with past choices
- If it does conflict, acknowledge the existing decision and explain why a change is warranted

**When encountering errors or bugs:**
- Search `docs/project_notes/bugs.md` for similar issues
- Apply known solutions if found
- Document new bugs and solutions when resolved

**When looking up project configuration:**
- Check `docs/project_notes/key_facts.md` for credentials, ports, URLs, service accounts
- Prefer documented facts over assumptions

**When completing work on tickets:**
- Log completed work in `docs/project_notes/issues.md`
- Include ticket ID, date, brief description, and URL

**When user requests memory updates:**
- Update the appropriate memory file (bugs, decisions, key_facts, or issues)
- Follow the established format and style (bullet lists, dates, concise entries)

### Style Guidelines for Memory Files

- **Prefer bullet lists over tables** for simplicity and ease of editing
- **Keep entries concise** (1-3 lines for descriptions)
- **Always include dates** for temporal context
- **Include URLs** for tickets, documentation, monitoring dashboards
- **Manual cleanup** of old entries is expected (not automated)

### 3. Configure AGENTS.md - Multi-Tool Support

Si el proyecto tiene un archivo AGENTS.md —usado para flujos de agentes o proyectos multiherramienta—, añade los mismos protocolos de memoria. Esto asegura consistencia tanto si usas Claude Code, Cursor, GitHub Copilot u otras herramientas de IA.
- Si AGENTS.md existe: añade la misma sección “Project Memory System” que arriba.
- Si AGENTS.md no existe: pregunta al usuario si quiere crearlo. Muchos proyectos usan múltiples herramientas de IA y se benefician de protocolos de memoria compartidos.

### 4. Searching Memory Files

When encountering problems or making decisions, proactively search memory files:

**Search bugs.md:**
```bash
# Look for similar errors
grep -i "connection refused" docs/project_notes/bugs.md

# Find bugs by date range
grep "2025-01" docs/project_notes/bugs.md

Search decisions.md:

Bash

# Check for decisions about a technology
grep -i "database" docs/project_notes/decisions.md

# Find all ADRs
grep "^### ADR-" docs/project_notes/decisions.md

Search key_facts.md:

Bash

# Find database connection info
grep -A 5 "Database" docs/project_notes/key_facts.md

# Look up service accounts
grep -i "service account" docs/project_notes/key_facts.md

Use Grep tool for more complex searches:

  • Search across all memory files: Grep(pattern="oauth", path="docs/project_notes/")
  • Context-aware search: Grep(pattern="bug", path="docs/project_notes/bugs.md", -A=3, -B=3)

¡Entendido! Vamos a limpiar todo ese bloque de código residual y a transformarlo en la versión en español con ese toque profesional, sofisticado y sutilmente femenino que unifica todo el blog. Al igual que antes, mantendremos toda la estructura intacta y las secciones técnicas completamente detalladas.

5. Actualización de archivos de memoria

Cuando el usuario solicite actualizaciones o cuando estés documentando problemas resueltos, actualiza el archivo de memoria correspondiente con total precisión:

Añadir un registro de bug:

Markdown

### YYYY-MM-DD - Breve descripción del bug
- **Issue**: Qué salió mal
- **Root Cause**: Por qué sucedió
- **Solution**: Cómo se solucionó
- **Prevention**: Cómo evitarlo en el futuro

Añadir una decisión (ADR):

Markdown

### ADR-XXX: Título de la decisión (YYYY-MM-DD)

**Contexto:**
- Por qué se necesitaba la decisión
- Qué problema resuelve

**Decisión:**
- Qué opción fue elegida

**Alternativas consideradas:**
- Opción 1 -> Por qué se rechazó
- Opción 2 -> Por qué se rechazó

**Consecuencias:**
- Beneficios
- Trade-offs (Cosas que se ceden)

Añadir datos clave (Key Facts):

  • Organiza de forma impecable por categorías (Proyecto GCP, Base de datos, API, Desarrollo local, etc.).
  • Utiliza listas con viñetas para una lectura rápida y clara.
  • Incluye detalles específicos tanto para los entornos de producción como de desarrollo.
  • Añade URLs directas para una navegación sin fricciones.
  • Nota: Recuerda consultar siempre references/key_facts_template.md para repasar las pautas de seguridad sobre lo que NO debes almacenar.

Añadir un registro de historial de trabajo:

Markdown

### YYYY-MM-DD - TICKET-ID: Breve descripción
- **Status**: Completado / En progreso / Bloqueado
- **Description**: Resumen de 1 o 2 líneas
- **URL**: https://jira.company.com/browse/TICKET-ID
- **Notes**: Cualquier contexto importante o advertencia

6. Mantenimiento de los archivos de memoria

Limpia periódicamente las entradas antiguas:

  • Responsabilidad manual: El usuario es completamente responsable de las limpiezas manuales (aquí prescindimos de automatizaciones intrusivas).
  • Rotación del registro de bugs: Elimina las entradas de bugs muy antiguas (más de 6 meses) que ya no sean relevantes para el estado actual del stack.
  • Archivo del registro de trabajo: Archiva el trabajo completado en issues.md una vez que supere los 3 meses de antigüedad.
  • Preserva las decisiones: Mantén intactos todos los registros históricos de ADR; son ligeros y aportan un valor incalculable para comprender la evolución del software.
  • Actualización de infraestructura: Modifica proactivamente key_facts.md en el instante preciso en que cambie la configuración del proyecto.

Resolución de conflictos:

  • Si propones un camino que entre en conflicto con decisions.md, tómate un momento para explicar por qué se justifica reabrir esa decisión pasada.
  • Asegúrate de actualizar la entrada de la decisión principal si la elección tecnológica a largo plazo cambia.
  • Añade siempre la fecha de revisión con total claridad para mostrar la evolución arquitectónica.

Plantillas y referencias

Esta skill incluye archivos de plantilla estructurados en el directorio references/ para garantizar un formato perfecto en todo tu equipo:

  • references/bugs_template.md – Estructura limpia para el registro de bugs con ejemplos del mundo real.
  • references/decisions_template.md – Formato estándar de ADR con ejemplos arquitectónicos.
  • references/key_facts_template.md – Organización de datos esenciales acompañada de estrictas directrices de seguridad.
  • references/issues_template.md – Formato de historial de trabajo diario con marcadores de posición para tickets.

Cuando comiences a desplegar la infraestructura inicial de memoria, simplemente copia estas plantillas directamente en docs/project_notes/ y personalízalas para adaptarlas al diseño único de tu proyecto.

Flujos de trabajo de ejemplo

Escenario 1: Encontrarse con un bug familiar

  • Usuario: "Estoy recibiendo un error 'connection refused' desde la base de datos."
  • Acción del agente interno: Escanea automáticamente docs/project_notes/bugs.md buscando la palabra "connection".
  • Resultado: Localiza una solución histórica: "Use AlloyDB Auth Proxy on port 5432".
  • Resolución: Aplica la solución conocida de inmediato, evitando tener que depurar desde cero.

Escenario 2: Proponer un cambio arquitectónico

  • Pensamiento del agente interno: "El usuario podría beneficiarse de usar SQLAlchemy para las migraciones."
  • Acción del agente interno: Revisa meticulosamente docs/project_notes/decisions.md antes de actuar.
  • Resultado: Encuentra el ADR-002 que estipula que el equipo ya eligió explícitamente Alembic para mantener la alineación técnica.
  • Resolución: Utiliza elegantemente Alembic en su lugar, manteniendo la consistencia del proyecto sin esfuerzo.

Escenario 3: El usuario solicita una actualización de memoria

  • Usuario: "Añade esa solución de CORS a nuestro registro de bugs."
  • Acción del agente interno: Lee docs/project_notes/bugs.md para capturar el contexto actual.
  • Resultado: Agrega una nueva entrada impecable detallando la fecha, la causa raíz, la solución y el mecanismo de prevención.
  • Resolución: Confirma con amabilidad y gracia al usuario que la adición fue un éxito.

Escenario 4: Buscar la configuración del proyecto

  • Pensamiento del agente interno: "Necesito establecer una conexión con la base de datos."
  • Acción del agente interno: Consulta docs/project_notes/key_facts.md antes de asumir cualquier parámetro.
  • Resultado: Identifica la sección dedicada a la Configuración de la Base de Datos.
  • Resolución: Extrae de forma segura las cadenas y parámetros de conexión documentados, dejando a un lado las conjeturas.

Consejos para una gestión efectiva de la memoria

  1. Sé proactiva: Revisa los archivos de memoria antes de proponer soluciones o cambios de código.
  2. Sé concisa: Mantén las entradas breves (de 1 a 3 líneas para las descripciones).
  3. Incluye fechas: Añade siempre fechas precisas para conservar el contexto temporal.
  4. Enlaza tu documentación: Incluye URLs directas a tickets, documentos de referencia y dashboards de monitoreo.
  5. Sé selectiva: Céntrate en problemas recurrentes o verdaderamente instructivos, no es necesario registrar cada pequeño error tipográfico.

Integración con otras skills

La skill project-memory se complementa de forma hermosa con otras herramientas de tu entorno:

  • requirements-documenter: Requisitos -> Decisiones (los ADRs sirven como referencia para los requisitos del proyecto).
  • root-cause-debugger: Diagnóstico de bugs -> Registro de bugs (documenta las soluciones inmediatamente después de los arreglos).
  • code-quality-reviewer: Problemas de calidad -> Decisiones (registra formalmente los estándares de calidad acordados).
  • docs-sync-editor: Cambios de código -> Datos clave (actualiza las notas en el momento en que cambie la configuración).

Cuando utilices estas herramientas en conjunto, considera la actualización de los archivos de memoria como una acción de cierre natural y orgánica.

Criterios de éxito

Esta skill se considera desplegada correctamente cuando:

  • Existe el directorio docs/project_notes/ albergando los cuatro archivos de memoria limpios.
  • El archivo CLAUDE.md incluye formalmente la sección “Project Memory System” junto con sus protocolos.
  • El archivo AGENTS.md refleja estos mismos protocolos (si el archivo existe o si lo solicitaste expresamente).
  • Los archivos de memoria siguen con absoluta fidelidad el formato de las plantillas y las guías de estilo estipuladas.
  • El asistente de IA comprueba minuciosamente los archivos de memoria antes de sugerir cualquier cambio.
  • Puedes solicitar actualizaciones de memoria con total fluidez (por ejemplo, “add this to bugs.md”).
  • Los archivos de memoria lucen como documentación de ingeniería estándar y profesional, alejándose por completo de parecer artefactos generados artificialmente por una IA.

---

```markdown
## Consejos para una gestión efectiva de memoria

1. **Sé proactiva**: revisa los archivos de memoria antes de proponer soluciones.
2. **Sé concisa**: mantén las entradas breves —1 a 3 líneas para descripciones—.
3. **Incluye fechas**: siempre incluye fechas para contexto temporal.
4. **Incluye enlaces**: añade URLs a tickets, documentación y dashboards de monitoreo.
5. **Sé selectiva**: enfócate en problemas recurrentes o instructivos, no en cada bug.

## Integración con otras skills

La skill `project-memory` complementa otras herramientas a la perfección:
- **requirements-documenter**: Requisitos -> Decisiones —los ADRs referencian requisitos—.
- **root-cause-debugger**: Diagnóstico de bugs -> Registro de bugs —documentar soluciones después de los arreglos—.
- **code-quality-reviewer**: Problemas de calidad -> Decisiones —documentar estándares de calidad—.
- **docs-sync-editor**: Cambios de código -> Datos clave —actualizar cuando cambia la configuración—.

Cuando utilices estas skills juntas, considera actualizar los archivos de memoria como una acción natural de seguimiento.

## Criterios de éxito

Esta skill está desplegada correctamente cuando:
- Existe el directorio `docs/project_notes/` con los cuatro archivos de memoria limpios.
- `CLAUDE.md` incluye la sección “Project Memory System” con todos sus protocolos.
- `AGENTS.md` incluye los mismos protocolos —si el archivo existe o el usuario lo solicitó—.
- Los archivos de memoria siguen de forma impecable el formato de la plantilla y las guías de estilo.
- El asistente de IA revisa minuciosamente los archivos de memoria antes de proponer cualquier cambio.
- El usuario puede pedir de forma fluida actualizaciones de memoria —por ejemplo, “add this to bugs.md”—.
- Los archivos de memoria parecen documentación estándar de ingeniería, alejándose por completo de lucir como artefactos de IA.

Gracias por leer Código en Casa.
Si esto te a ayudado y te sumo algo Dale un 👏 , compártelo con tu red o dejame un comentario para saber tu opinión.