Guía de memoria

La memoria permite a Claude conservar el contexto a través de sesiones y conversaciones. Existe en dos formas: síntesis automática en claude.ai, y CLAUDE.md basado en sistemas de archivos en Claude Code.

Introducción

La memoria en Claude Code proporciona un contexto persistente que lleva a través de varias sesiones y conversaciones. A diferencia de las ventanas temporales de contexto, los archivos de memoria le permiten:

• Comparta los estándares del proyecto con su equipo
• Almacenar preferencias de desarrollo personal
• Mantener reglas y configuraciones específicas del directorio
• Importar documentación externa
• Memoria de control de versiones como parte de su proyecto

El sistema de memoria funciona a múltiples niveles, desde preferencias personales globales hasta subdirectorios específicos, lo que permite un control de grano fino sobre lo que Claude recuerda y cómo aplica ese conocimiento.

Referencia rápida de órdenes de memoria

Inicio rápido: Inicializando memoria

Los /init Comando

Los /init comando es la forma más rápida de configurar la memoria del proyecto en Claude Code. Inicializa un archivo CLAUDE.md con documentación de proyecto fundacional.

Uso:

/init

Lo que hace:

• Crea un nuevo archivo CLAUDE.md en su proyecto (normalmente en ./CLAUDE.md o ./.claude/CLAUDE.md)
• Establece convenciones y directrices para proyectos
• Establece las bases para la persistencia del contexto en todas las sesiones
• Proporciona una estructura de plantilla para documentar los estándares de su proyecto

Modo interactivo mejorado: Establecer CLAUDE_CODE_NEW_INIT=1 para habilitar un flujo interactivo multifásico que te lleve paso a paso a través de la configuración del proyecto:

CLAUDE_CODE_NEW_INIT=1 claude
/init

Cuándo usar /init:

• Iniciando un nuevo proyecto con Claude Code
• Establecimiento de normas y convenciones de codificación por equipos
• Crear documentación sobre su estructura de base de código
• Establecimiento de una jerarquía de memoria para el desarrollo colaborativo

Ejemplo de flujo de trabajo:

# In your project directory
/init

# Claude creates CLAUDE.md with structure like:
# Project Configuration
## Project Overview
- Name: Your Project
- Tech Stack: [Your technologies]
- Team Size: [Number of developers]

## Development Standards
- Code style preferences
- Testing requirements
- Git workflow conventions

Actualizaciones rápidas de memoria

Nota: El # se suspendió el acceso directo para la memoria en línea. /memory para editar archivos de memoria directamente, o pedir a Claude conversacionalmente que recuerde algo (por ejemplo, "recordemos que siempre usamos el modo estricto de TypeScript").

Las formas recomendadas de agregar información a la memoria son:

Opción 1: Utilización /memory comando

/memory

Abre los archivos de memoria en el editor de su sistema para su edición directa.

Opción 2: Preguntar en conversación

Remember that we always use TypeScript strict mode in this project.
Please add to memory: prefer async/await over promise chains.

Pedir a Claude que recuerde algo lo guarda en la memoria automática. Para cambiar CLAUDE.md en su lugar, diga "añadir esto a CLAUDE.md", o edite el archivo usted mismo con /memory.

Referencia histórica (ya no es funcional):

Los # prefijo acceso directo previamente permitido añadir reglas en línea:

# Always use TypeScript strict mode in this project  ← no longer works

Si confías en este patrón, cambia a la /memory órdenes o peticiones de conversación.

Los /memory Comando

Los /memory el comando proporciona acceso directo para editar sus archivos de memoria CLAUDE.md en las sesiones de Claude Code. Abre los archivos de memoria en su editor de sistema para una edición completa. Cuando el archivo se abre en un editor de interfaz gráfica, la sesión ya no bloquea mientras el archivo permanece abierto, por lo que puede seguir trabajando en paralelo (v2.1.216); editores de terminales como Vim todavía toman el control de la terminal hasta que salga.

Uso:

/memory

Lo que hace:

• Abre sus archivos de memoria en el editor predeterminado de su sistema
• Le permite hacer amplia adiciones, modificaciones y reorganizaciones
• Proporciona acceso directo a todos los archivos de memoria en la jerarquía
• Le permite gestionar el contexto persistente a través de las sesiones

Cuándo usar /memory:

• Revisión del contenido de memoria existente
• Realización de amplias actualizaciones de las normas del proyecto
• Reorganizando la estructura de la memoria
• Añadir documentación o directrices detalladas
• Mantener y actualizar la memoria a medida que su proyecto evoluciona

Comparación: /memory vs. /init

Ejemplo de flujo de trabajo:

# Open memory for editing
/memory

# Claude presents options:
# 1. Managed Policy Memory
# 2. Project Memory (./CLAUDE.md)
# 3. User Memory (~/.claude/CLAUDE.md)
# 4. Local Project Memory

# Choose option 2 (Project Memory)
# Your default editor opens with ./CLAUDE.md content

# Make changes, save, and close editor
# Claude automatically reloads the updated memory

Usando las importaciones de memoria:

Los archivos CLAUDE.md soportan el @path/to/file sintaxis para incluir contenido externo:

# Project Documentation
See @README.md for project overview
See @package.json for available npm commands
See @docs/architecture.md for system design

# Import from home directory using absolute path
@~/.claude/my-project-instructions.md

Importar características:

• Se apoyan caminos tanto relativos como absolutos (por ejemplo, @docs/api.md o @~/.claude/my-project-instructions.md)
• Las importaciones recursivas se apoyan con una profundidad máxima de 4 lúpulo
• Las importaciones por primera vez desde ubicaciones externas activan un diálogo de aprobación de seguridad
• Las directivas de importación no se evalúan dentro de los rangos de código de marcado o bloques de código (por lo que documentarlas en ejemplos es seguro)
• Ayuda a evitar la duplicación haciendo referencia a la documentación existente
• Incluye automáticamente contenido referenciado en el contexto de Claude

Arquitectura de memoria

La memoria en Claude Code sigue un sistema jerárquico donde los diferentes alcances sirven para diferentes propósitos. Memoria en Claude Web/Desktop abajo), Claude Code tiene dos sistemas de memoria que se cargan al inicio de cada sesión y se actualizan continuamente, no en un temporizador:

graph TB
    A["Inicio de la sesión"]
    B["Archivos CLAUDE.md<br/>(Tú escribes)"]
    C["Memoria automática<br/>(Claude escribe)"]
    D["Sesión de Claude"]
    E["Su corrección /<br/>Preferencia"]

    B -->|cargados en su totalidad| A
    C -->|Memory.md cargado| A
    A --> D
    D -->|"Recuérdalo..."| E
    E -->|escribe durante la sesión| C
    D -->|"añadir esto a CLAUDE.md"| B

Jerarquía de la memoria en Claude Code

Claude Code tiene dos sistemas de memoria complementarios, ambos cargados al comienzo de cada conversación: Archivos CLAUDE.md (instrucciones que escribes) y memoria automática (notas Claude se escribe a sí mismo). Concatenados en contexto en lugar de prevalecer entre sí — no se trata de una cadena de precedencia estricta en la que un nivel superior sustituye a otro inferior. .claude/rules/*.md los archivos son un mecanismo separado, relacionado para las instrucciones de tópico- o de la trayectoria-.

CLAUDE.md ubicaciones de archivos, en orden de carga (ámbito más amplio a más específico):

Dentro del árbol de directorios, Claude Code aparece desde su directorio de trabajo: foo/CLAUDE.md cargas antes foo/bar/CLAUDE.md si se lanza desde foo/bar/, por lo que las instrucciones más cerca de donde se lanza se lee último — no "prioridad más alta" en un sentido de anulación, sólo más reciente en el contexto. CLAUDE.local.md se adjunta después de CLAUDE.mdArchivos CLAUDE.md y CLAUDE.local.md en subdirectorios bajo su directorio de trabajo carga bajo demanda, cuando Claude lee los archivos en esos subdirectorios, en lugar de en el lanzamiento. Desde v2.1.309, un archivo bajo demanda sobre un límite de tamaño por archivo carga sólo su inicio, terminando con una nota diciendo a Claude que lea el resto. CLAUDE.md/CLAUDE.local.md y sus @ importaciones, normas en un subdirectorio .claude/rules/, y reglas de alcance de trayectoria en .claude/rules/ o ~/.claude/rules/. El límite es de 40.000 caracteres con una ventana de contexto de 200K. Con una ventana de 1M es de 200.000 caracteres en Opus 4.6 y Sonnet 4.6, y 150.000 en modelos posteriores. wc -m path/to/CLAUDE.md.

Las organizaciones también pueden poner contenido CLAUDE.md gestionado directamente dentro managed-settings.json a través de claudeMd clave, en lugar de implementar un archivo separado. Esto se honra sólo en la configuración administrada / política — configuración claudeMd en la configuración del usuario o proyecto no tiene efecto.

.claude/rules/*.md — instrucciones modulares, específicas para cada tema, con un alcance opcional para archivar rutas a través de paths frontmatter. Reglas sin una paths carga de campo incondicionalmente con la misma prioridad que .claude/CLAUDE.md; las reglas de acceso se cargan a la demanda cuando Claude lee, escribe o edita un archivo que coincide, incluyendo verlo con un único archivo Bash leído como: cat, head, tail, sed -no bien grep (Escritura/Editar desde v2.1.288, Bash lee desde v2.1.293).~/.claude/rules/) cargar antes de las reglas del proyecto. paths patrón es relativo al directorio base de la regla: para las reglas del proyecto, el directorio que contiene la regla .claude para reglas de nivel de usuario, el directorio de trabajo primario de la sesión. Para tener reglas de acceso para archivos en un hermano git worktree, inicie Claude Code en ese árbol de trabajo o mueva la sesión allí con /cd.

Memoria automática (~/.claude/projects/<project>/memory/) es un sistema separado: las propias notas de Claude, no contenido CLAUDE.md, y no parte del orden de concatenación anterior. Memoria automática abajo.

Nota: CLAUDE.local.md está plenamente apoyado y documentado en el documentación oficial. Proporciona preferencias personales específicas del proyecto que no están comprometidas con el control de la versión. CLAUDE.local.md a tu .gitignore.

Comportamiento de descubrimiento de memoria:

graph TD
    A["Política administrada<br/>/Library/.../ClaudeCode/CLAUDE.md"] -->|cargas primero| B["Instrucciones de uso<br/>~/.claude/CLAUDE.md"]
    B --> C["Instrucciones del proyecto<br/>./CLAUDE.md o ./.claude/CLAUDE.md"]
    C --> D["Instrucciones locales<br/>./CLAUDE.local.md"]

    C -->|imports| H["@docs/architecture.md"]
    H -->|imports| I["@docs/api-standards.md"]

    style A fill:#fce4ec,stroke:#333,color:#333
    style B fill:#f3e5f5,stroke:#333,color:#333
    style C fill:#e1f5fe,stroke:#333,color:#333
    style D fill:#e8f5e9,stroke:#333,color:#333
    style H fill:#e1f5fe,stroke:#333,color:#333
    style I fill:#e1f5fe,stroke:#333,color:#333

Todos los archivos mostrados están concatenados en un contexto, no seleccionados por la anulación — las casillas posteriores aparecen más adelante en contexto, no "en lugar de" los anteriores.

AGENTS.md

AGENTS.md es un archivo cross-tool proyecto-contexto: el mismo Categoría de documento como CLAUDE.md, escrito para que varios agentes de codificación puedan compartir un conjunto de convenciones del proyecto. v2.1.277, Claude Code lo lee directamente como instrucciones de proyecto en lugar de exigir que lo importe.

Comportamiento predeterminado (claude-md-or-agents-md):

Que archivos suprimen AGENTS.md. Claude Code comprueba el directorio de trabajo y cada directorio por encima de él para CLAUDE.md, .claude/CLAUDE.mdo bien CLAUDE.local.mdSi encuentra alguno de ellos, AGENTS.md no se lee. ~/.claude/CLAUDE.md, manejado CLAUDE.md, y .claude/rules/ hacer no cuenta para este cheque y sigue cargando junto a cualquier archivo de proyecto que gane.

Aviso: añadir un CLAUDE.local.md se detiene silenciosamente AGENTS.md Si las instrucciones de su proyecto parecen desaparecer después de crear una anulación local, por lo general es por eso.

Lo que se lee. Cada AGENTS.md y .claude/AGENTS.md en y por encima del directorio de trabajo se carga al inicio de la sesión; los archivos en subdirectorios se cargan a petición, cuando Claude lee los archivos allí. @path las importaciones se expanden de la misma manera que en CLAUDE.md, y claudeMdExcludes se aplica.

Lo que nunca se lee: AGENTS.local.md, AGENTS.override.md, y cualquier cosa bajo .agents/.

Escoger el comportamiento. Los Instrucciones del proyecto la configuración requiere cuatro valores:

Arréglalo /config, o en la configuración:

{
  "pluginConfigs": {
    "agents-md@builtin": {
      "options": {
        "instructionFiles": "claude-md-and-agents-md"
      }
    }
  }
}

Esta clave es honrada en la configuración de usuario y administrada solamente — configurarla en la configuración del proyecto o local no tiene efecto.

Donde la lectura directa no está disponible. En versiones anteriores a v2.1.277 (o antes de v2.1.281 en Bedrock/Vertex/Foundry, detrás de las pasarelas LLM, o con telemetría desactivada), durante la primera sesión después de la actualización, o con el incorporado agents-md plugin desactivado, Claude Code no recogerá AGENTS.md En estos casos, importarlo de CLAUDE.md:

@AGENTS.md

Excluyendo archivos CLAUDE.md con claudeMdExcludes

En monorepos grandes, algunos archivos CLAUDE.md pueden ser irrelevantes para su trabajo actual. claudeMdExcludes configuración le permite saltar archivos CLAUDE.md específicos para que no se carguen en contexto:

// In ~/.claude/settings.json or .claude/settings.json
{
  "claudeMdExcludes": [
    "**/packages/legacy-app/CLAUDE.md",
    "**/vendors/**/CLAUDE.md"
  ]
}

Los patrones se comparan con rutas de archivos absolutas usando sintaxis glob, por lo que iniciar patrones repo-relativos con **/. Esto es particularmente útil para:

• Monorepos con muchos subproyectos, donde sólo algunos son relevantes
• Repositorios que contienen archivos CLAUDE.md de proveedores o terceros
• Reducir el ruido en la ventana de contexto de Claude excluyendo las instrucciones rancios o no relacionadas

Preferencias Jerarquía de archivos

Configuración de Claude Code (incluyendo autoMemoryDirectory, claudeMdExcludes, y otra configuración) resolver por precedencia — a diferencia de los archivos CLAUDE.md anteriores, las configuraciones realmente anulan en lugar de concatenar. Cuando la misma configuración aparece en múltiples alcances, el nivel superior gana:

La configuración administrada también admite un directorio desplegable, managed-settings.d/, junto a managed-settings.json: el archivo base se fusiona primero, luego *.json Los archivos en el directorio desplegable se fusionan en orden alfabético (supervisar escalares, concatenar arrays y de-duplicar, objetos de fusión profunda). Esto permite a equipos separados implementar fragmentos de políticas independientes sin editar un archivo compartido. settings.json mecanismo, no un CLAUDE.md uno — no se aplica a las ubicaciones de archivos CLAUDE.md descritas anteriormente.

Normas de autorización (allow/ask/deny) se comportan de manera diferente a otras configuraciones: se funden entre los distintos ámbitos en lugar del nivel superior que sustituye al inferior.

Configuración específica de la plataforma (v2.1.51+):

Las configuraciones también se pueden configurar mediante: - macOS: Lista de propiedades (plista) archivos - Windows: Registro de Windows

Estos mecanismos de plataforma nativa se leen junto con los archivos de configuración de JSON y siguen las mismas reglas de precedencia.

Nota (v2.1.119): /config los cambios que se están produciendo ~/.claude/settings.json. Valores escritos a través de /config participar en la cadena de precedencia normal de políticas/locales/proyectos descrita anteriormente; ya no son sólo sesiones. /config para ediciones interactivas y editar settings.json archivos directamente para la configuración con script o administrada.

Configuración de retención y limpieza

// ~/.claude/settings.json
{
  "cleanupPeriodDays": 14
}

Atribución, voz y configuración de URL PR

// ~/.claude/settings.json
{
  "attribution": {
    "commit": "",
    "pr": ""
  },
  "voice": {
    "enabled": true
  },
  "prUrlTemplate": "https://reviews.example.com/{owner}/{repo}/pull/{number}"
}

Una cadena vacía ("") oculta esa atribución; "attribution": false lo oculta todo (v2.1.281+).

Nombres de configuración obsoletos

Las siguientes teclas de configuración del legado aún funcionan, pero están obsoletas. Prefiere los reemplazos anteriores.

Sistema de reglas modulares

Crear reglas organizadas, específicas de la ruta usando el .claude/rules/ Las reglas se pueden definir tanto a nivel de proyecto como de usuario:

your-project/
├── .claude/
│   ├── CLAUDE.md
│   └── rules/
│       ├── code-style.md
│       ├── testing.md
│       ├── security.md
│       └── api/                  # Subdirectories supported
│           ├── conventions.md
│           └── validation.md

~/.claude/
├── CLAUDE.md
└── rules/                        # User-level rules (all projects)
    ├── personal-style.md
    └── preferred-patterns.md

Reglas se descubren recursivamente dentro de la rules/ directorio, incluyendo cualquier subdirectorio. Reglas de nivel de usuario en ~/.claude/rules/ se cargan antes de las reglas de nivel de proyecto, permitiendo por defecto personales que los proyectos pueden anular.

Reglas específicas de ruta con YAML Frontmatter

Definir reglas que solo se aplican a rutas de archivos específicas:

---
paths: src/api/**/*.ts
---

# API Development Rules

- All API endpoints must include input validation
- Use Zod for schema validation
- Document all parameters and response types
- Include error handling for all operations

Ejemplos de patrones Glob:

• **/*.ts - Todos los archivos TypeScript
• src/**/* - Todos los archivos bajo src/
• src/**/*.{ts,tsx} - Múltiples extensiones
• {src,lib}/**/*.ts, tests/**/*.test.ts - Patrones múltiples

Subdirectorios y enlaces simbólicos

Reglas en .claude/rules/ apoyar dos características organizativas:

• Subdirectorios: Las reglas se descubren recursivamente, por lo que puede organizarlas en carpetas basadas en temas (por ejemplo, rules/api/, rules/testing/, rules/security/)
• Vínculos entre sí: Los Symlinks son compatibles para compartir reglas entre varios proyectos. Por ejemplo, puede enlazar un archivo de reglas compartidas desde una ubicación central a la de cada proyecto .claude/rules/ desde v2.1.284, una regla simbilizada desde fuera del proyecto — o un .claude directorio simbionteado desde el exterior — muestra la misma aprobación de importaciones externas @path importación

Tabla de ubicaciones de memoria

Los archivos y reglas CLAUDE.md se concatenan en contexto, no seleccionados por una estricta anulación — "Orden de carga" a continuación significa donde en el contexto aparece, no que uno gana. La memoria automática es un mecanismo separado con su propia ubicación de almacenamiento.

Actualización de memoria ciclo de vida

Así es como las actualizaciones de memoria fluyen a través de sus sesiones de Claude Code:

sequenceDiagram
    participant User
    participant Claude as Claude Code
    participant Editor as File System
    participant Memory as CLAUDE.md

    User->>Claude: "Añadir la regla async/await a CLAUDE.md"
    Claude->>User: "¿Qué archivo de memoria?"
    User->>Claude: "Memoria del proyecto"
    Claude->>Editor: Open ./CLAUDE.md
    Claude->>Memory: Write to ./CLAUDE.md
    Memory-->>Claude: File saved
    Claude->>Claude: Load updated memory
    Claude-->>User: "¡Memoria salvada!"

Memoria automática

La memoria automática es un directorio persistente donde Claude guarda automáticamente notas mecanografiadas (user, feedback, project, reference) como funciona con su proyecto. Se salta cualquier cosa que puede derivar de la base de código, tales como arquitectura, rutas de archivos, o correcciones de depuración. A diferencia de los archivos CLAUDE.md que usted escribe y mantiene manualmente, la memoria automática es escrita por el propio Claude durante las sesiones.

Cómo funciona la memoria automática

• Zona: ~/.claude/projects/<project>/memory/
• Punto de entrada: MEMORY.md sirve como el archivo principal en el directorio de memoria automática
• Archivos de temas: Archivos adicionales opcionales, uno por memoria (por ejemplo, prefers-pnpm.md, release-checklist.md)
• Comportamiento de carga: Las primeras 200 líneas de MEMORY.md (o primero 25KB, lo que viene primero) se cargan en el contexto al inicio de la sesión. Los archivos de tema se cargan bajo demanda, no al inicio.
• Read/write: Claude lee y escribe archivos de memoria durante las sesiones mientras aprende sus preferencias, comentarios y contexto del proyecto
• Frontmatter: Archivos que comienzan con YAML frontmatter obtener un modified campo — una marca de tiempo ISO 8601 Claude Code registra cada vez que escribe el archivo (v2.1.214)

Arquitectura de memoria automática

graph TD
    A["Comienza la sesión de Claude"] --> B["Cargar MEMORIA.md<br/>(primeras 200 líneas / 25KB)"]
    B --> C["Sesión activa"]
    C --> D["Claude aprende<br/>& feedback de preferencias"]
    D --> E{"Escribir a<br/>memoria automática"}
    E -->|Notas generales| F["MEMORY.md"]
    E -->|Topic-specific| G["prefers-pnpm.md"]
    E -->|Topic-specific| H["release-checklist.md"]
    C --> I["Carga bajo demanda<br/>archivos de temas"]
    I --> C

    style A fill:#e1f5fe,stroke:#333,color:#333
    style B fill:#e1f5fe,stroke:#333,color:#333
    style C fill:#e8f5e9,stroke:#333,color:#333
    style D fill:#f3e5f5,stroke:#333,color:#333
    style E fill:#fff3e0,stroke:#333,color:#333
    style F fill:#fce4ec,stroke:#333,color:#333
    style G fill:#fce4ec,stroke:#333,color:#333
    style H fill:#fce4ec,stroke:#333,color:#333
    style I fill:#f3e5f5,stroke:#333,color:#333

Estructura de directorio de memoria automática

~/.claude/projects/<project>/memory/
├── MEMORY.md              # Entrypoint (first 200 lines / 25KB loaded at startup)
├── prefers-pnpm.md        # Topic file (loaded on demand)
├── release-checklist.md   # Topic file (loaded on demand)
└── team-contacts.md       # Topic file (loaded on demand)

Requisito de la versión

La memoria automática requiere Claude Code v2.1.59 o posterior. Si está en una versión anterior, actualice primero:

npm install -g @anthropic-ai/claude-code@latest

Activar o desactivar la memoria automática

La memoria automática es activada por defecto. El autoMemoryEnabled ajuste (predeterminado true) la controla; cuando false, Claude no lee ni escribe en el directorio de memoria automática. También puede cambiarlo con /memory durante una sesión.

{
  "autoMemoryEnabled": false
}

Para deshabilitarlo a través del entorno en su lugar, establecer CLAUDE_CODE_DISABLE_AUTO_MEMORY=1. Ajustándolo a 0 fuerza la memoria automática el incluso cuando --bare modo o autoMemoryEnabled: false De lo contrario, lo desactivaría.

Directorio de memoria automática personalizado

Por defecto, la memoria automática se almacena en ~/.claude/projects/<project>/memory/. Puede cambiar esta ubicación usando el autoMemoryDirectory (disponible desde v2.1.74):

// In any settings file: user, project, local, or managed policy
{
  "autoMemoryDirectory": "/path/to/custom/memory/directory"
}

Nota: autoMemoryDirectory se lee desde cualquier ámbito de configuración: usuario, proyecto, política local, administrada, o --settings. El valor debe ser un camino absoluto o comenzar con ~/.

Esto es útil cuando se desea:

• Almacenar la memoria automática en una ubicación compartida o sincronizada
• Separar la memoria automática del directorio predeterminado de configuración de Claude
• Usar una ruta específica del proyecto fuera de la jerarquía predeterminada

Worktree y Repository Sharing

Todos los worktrees y subdirectories dentro del mismo repositorio git comparten un único directorio de memoria automática. Esto significa que el cambio entre worktrees o trabajar en diferentes subdirectorios de la misma repo leerá y escribirá a los mismos archivos de memoria.

Memoria de subagente

Los subagentes (aparecen a través de la herramienta Agent) pueden mantener su propia memoria persistente. memory El campo frontmatter en la definición de subagente selecciona dónde vive ese directorio de memoria:

memory: user      # ~/.claude/agent-memory/<agent-name>/
memory: project   # .claude/agent-memory/<agent-name>/ (shareable via git)
memory: local     # .claude/agent-memory-local/<agent-name>/ (not checked in)

El subagente lee las primeras 200 líneas / 25KB de ese directorio MEMORY.md al inicio y obtiene Read/Write/Edit para mantenerlo. No tiene efecto cuando la memoria automática está desactivada.

Nota: Los subagentes también pueden mantener su propia memoria automática. documentación oficial de memoria de subagente para más detalles.

Controlando la memoria automática

La memoria automática se puede controlar a través de la CLAUDE_CODE_DISABLE_AUTO_MEMORY variable de entorno:

# Disable auto memory for a session
CLAUDE_CODE_DISABLE_AUTO_MEMORY=1 claude

# Force auto memory on explicitly
CLAUDE_CODE_DISABLE_AUTO_MEMORY=0 claude

Directorios adicionales con --add-dir

Los --add-dir flag permite a Claude Code cargar archivos CLAUDE.md desde directorios adicionales más allá del directorio de trabajo actual. Esto es útil para configuraciones monorepos o multiproyecto donde el contexto de otros directorios es relevante.

Para habilitar esta función, establezca la variable de entorno:

CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1

Luego lanza Claude Code con la bandera:

claude --add-dir /path/to/other/project

Claude cargará CLAUDE.md desde el directorio adicional especificado junto con los archivos de memoria de su directorio de trabajo actual.

Ejemplos prácticos

Ejemplo 1: Estructura de la memoria del proyecto

Archivo: ./CLAUDE.md

# Project Configuration

## Project Overview
- **Name**: E-commerce Platform
- **Tech Stack**: Node.js, PostgreSQL, React 18, Docker
- **Team Size**: 5 developers
- **Deadline**: Q4 2025

## Architecture
@docs/architecture.md
@docs/api-standards.md
@docs/database-schema.md

## Development Standards

### Code Style
- Use Prettier for formatting
- Use ESLint with airbnb config
- Maximum line length: 100 characters
- Use 2-space indentation

### Naming Conventions
- **Files**: kebab-case (user-controller.js)
- **Classes**: PascalCase (UserService)
- **Functions/Variables**: camelCase (getUserById)
- **Constants**: UPPER_SNAKE_CASE (API_BASE_URL)
- **Database Tables**: snake_case (user_accounts)

### Git Workflow
- Branch names: `feature/description` or `fix/description`
- Commit messages: Follow conventional commits
- PR required before merge
- All CI/CD checks must pass
- Minimum 1 approval required

### Testing Requirements
- Minimum 80% code coverage
- All critical paths must have tests
- Use Jest for unit tests
- Use Cypress for E2E tests
- Test filenames: `*.test.ts` or `*.spec.ts`

### API Standards
- RESTful endpoints only
- JSON request/response
- Use HTTP status codes correctly
- Version API endpoints: `/api/v1/`
- Document all endpoints with examples

### Database
- Use migrations for schema changes
- Never hardcode credentials
- Use connection pooling
- Enable query logging in development
- Regular backups required

### Deployment
- Docker-based deployment
- Kubernetes orchestration
- Blue-green deployment strategy
- Automatic rollback on failure
- Database migrations run before deploy

## Common Commands

| Command | Purpose |
|---------|---------|
| `npm run dev` | Start development server |
| `npm test` | Run test suite |
| `npm run lint` | Check code style |
| `npm run build` | Build for production |
| `npm run migrate` | Run database migrations |

## Team Contacts
- Tech Lead: Sarah Chen (@sarah.chen)
- Product Manager: Mike Johnson (@mike.j)
- DevOps: Alex Kim (@alex.k)

## Known Issues & Workarounds
- PostgreSQL connection pooling limited to 20 during peak hours
- Workaround: Implement query queuing
- Safari 14 compatibility issues with async generators
- Workaround: Use Babel transpiler

## Related Projects
- Analytics Dashboard: `/projects/analytics`
- Mobile App: `/projects/mobile`
- Admin Panel: `/projects/admin`

Ejemplo 2: Memoria específica del directorio

Archivo: ./src/api/CLAUDE.md

# API Module Standards

This file supplements root CLAUDE.md for everything in /src/api/. Memory files are
concatenated, not overridden — the root CLAUDE.md still applies, and Claude Code
loads this file on demand when it reads, writes, or edits files in this subtree.

## API-Specific Standards

### Request Validation
- Use Zod for schema validation
- Always validate input
- Return 400 with validation errors
- Include field-level error details

### Authentication
- All endpoints require JWT token
- Token in Authorization header
- Token expires after 24 hours
- Implement refresh token mechanism

### Response Format

All responses must follow this structure:

```json
{
  "success": true,
  "data": { /* actual data */ },
  "timestamp": "2025-11-06T10:30:00Z",
  "version": "1.0"
}
```

Error responses:
```json
{
  "success": false,
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "User message",
    "details": { /* field errors */ }
  },
  "timestamp": "2025-11-06T10:30:00Z"
}
```

### Pagination
- Use cursor-based pagination (not offset)
- Include `hasMore` boolean
- Limit max page size to 100
- Default page size: 20

### Rate Limiting
- 1000 requests per hour for authenticated users
- 100 requests per hour for public endpoints
- Return 429 when exceeded
- Include retry-after header

### Caching
- Use Redis for session caching
- Cache duration: 5 minutes default
- Invalidate on write operations
- Tag cache keys with resource type

Ejemplo 3: Memoria personal

Archivo: ~/.claude/CLAUDE.md

# My Development Preferences

## About Me
- **Experience Level**: 8 years full-stack development
- **Preferred Languages**: TypeScript, Python
- **Communication Style**: Direct, with examples
- **Learning Style**: Visual diagrams with code

## Code Preferences

### Error Handling
I prefer explicit error handling with try-catch blocks and meaningful error messages.
Avoid generic errors. Always log errors for debugging.

### Comments
Use comments for WHY, not WHAT. Code should be self-documenting.
Comments should explain business logic or non-obvious decisions.

### Testing
I prefer TDD (test-driven development).
Write tests first, then implementation.
Focus on behavior, not implementation details.

### Architecture
I prefer modular, loosely-coupled design.
Use dependency injection for testability.
Separate concerns (Controllers, Services, Repositories).

## Debugging Preferences
- Use console.log with prefix: `[DEBUG]`
- Include context: function name, relevant variables
- Use stack traces when available
- Always include timestamps in logs

## Communication
- Explain complex concepts with diagrams
- Show concrete examples before explaining theory
- Include before/after code snippets
- Summarize key points at the end

## Project Organization
I organize my projects as:

   project/
   ├── src/
   │   ├── api/
   │   ├── services/
   │   ├── models/
   │   └── utils/
   ├── tests/
   ├── docs/
   └── docker/

## Tooling
- **IDE**: VS Code with vim keybindings
- **Terminal**: Zsh with Oh-My-Zsh
- **Format**: Prettier (100 char line length)
- **Linter**: ESLint with airbnb config
- **Test Framework**: Jest with React Testing Library

Mi prueba Pídele a Claude que guarde una nueva regla

Claude no ha salvado la regla porque yo no tenía ninguna Claude.md Entonces le pidió a Claude que confirmara la ubicación.

Ejemplo 4: Actualización de memoria durante la sesión

Puede añadir nuevas reglas a CLAUDE.md durante una sesión activa de Claude Code pidiéndole directamente a Claude (pediendo a Recuerda algo guarda la memoria automática en su lugar):

User: Add this to CLAUDE.md: I prefer using React hooks instead of class components
     for all new components.

Claude: I'm adding that to your memory. Which memory file should this go in?
        1. Project memory (./CLAUDE.md)
        2. Personal memory (~/.claude/CLAUDE.md)

User: Project memory

Claude: ✅ Memory saved!

Added to ./CLAUDE.md:
---

### Component Development
- Use functional components with React Hooks
- Prefer hooks over class components
- Custom hooks for reusable logic
- Use useCallback for event handlers
- Use useMemo for expensive computations

O usar /memory editar archivos de memoria directamente para actualizaciones extensas o reorganización.

Consejos para agregar memoria

• Sea específico y procesable en sus reglas
• Agrupar las normas relacionadas con una sección encabezada
• Actualizar secciones existentes en lugar de duplicar contenido
• Elija el ámbito de memoria apropiado (proyecto vs. personal)

Comparación de características de memoria

Memoria en Claude Web/Desktop

Cronograma de síntesis de memoria

graph LR
    A["Día 1: Usuario<br/>Conversaciones"] -->|24 horas| B["Día 2: Memoria<br/>Síntesis"]
    B -->|Automatic| C["Memoria actualizada<br/>Resumen"]
    C -->|Cargado en| D["Día 2-N:<br/>Nuevas conversaciones"]
    D -->|Añadir a| E["Memory"]
    E -->|24 horas más tarde| F["Refrescada la memoria"]

Resumen de memoria de ejemplo:

## Claude's Memory of User

### Professional Background
- Senior full-stack developer with 8 years experience
- Focus on TypeScript/Node.js backends and React frontends
- Active open source contributor
- Interested in AI and machine learning

### Project Context
- Currently building e-commerce platform
- Tech stack: Node.js, PostgreSQL, React 18, Docker
- Working with team of 5 developers
- Using CI/CD and blue-green deployments

### Communication Preferences
- Prefers direct, concise explanations
- Likes visual diagrams and examples
- Appreciates code snippets
- Explains business logic in comments

### Current Goals
- Improve API performance
- Increase test coverage to 90%
- Implement caching strategy
- Document architecture

Mejores prácticas

Hacer - Qué incluir

• Sea específico y detallado: Utilice instrucciones claras y detalladas en lugar de una guía vaga
• • Bien: "Utilice la sangría de 2 espacios para todos los archivos JavaScript"

• Evita: "Sigue las mejores prácticas"

• Mantener organizado: Estructurar archivos de memoria con secciones y encabezados claros

• Utilizar niveles jerárquicos adecuados:

• Política administrada: Políticas para toda la empresa, normas de seguridad, requisitos de cumplimiento
• Memoria del proyecto: Estándares de equipo, arquitectura, convenciones de codificación (compromiso con git)
• Memoria de usuario: Preferencias personales, estilo de comunicación, opciones de herramientas

• Memoria de directorio: Reglas específicas del módulo y anulaciones

• Importaciones de apalancamiento: Usar @path/to/file sintaxis para hacer referencia a la documentación existente

• Soporta una profundidad máxima de 4 lúpulo para importaciones recursivas
• Evita la duplicación entre archivos de memoria

• Ejemplo See @README.md for project overview

• Documentar órdenes frecuentes: Incluya comandos que utiliza repetidamente para ahorrar tiempo

• Memoria del proyecto de control de versiones: Comprometer archivos CLAUDE.md a nivel de proyecto a git para beneficio del equipo

• Revisión periódica: Actualizar la memoria regularmente a medida que evolucionan los proyectos y cambian los requisitos

• Facilite ejemplos concretos: Incluir fragmentos de código y escenarios específicos

No - Qué evitar

• No guardes secretos.: Nunca incluya claves de API, contraseñas, tokens o credenciales

• No incluya datos sensibles: Sin PII, información privada, o secretos de propiedad

• No duplicar el contenido: Importaciones de utilización (@path) hacer referencia a la documentación existente en su lugar

• No seas vago.: Evitar declaraciones genéricas como "seguir las mejores prácticas" o "escribir un buen código"

• No lo hagas demasiado largo.Objetivo bajo 200 líneas por CLAUDE.md. Los archivos más largos en el lanzamiento todavía se cargan en su totalidad, pero la adherencia disminuye — ver Mantener pequeño CLAUDE.md más abajo

• No se sobreorganicen.: Usar jerarquía estratégicamente; no crear superposiciones de subdirectorio excesivas

• No olvides actualizar: La memoria rancio puede causar confusión y prácticas anticuadas

• No exceda los límites de anidación: Las importaciones de memoria soportan una profundidad máxima de 4 lúpulo

Mantener pequeño CLAUDE.md

La guía actual de Anthropic es lo contrario de "poner todo en CLAUDE.md". cada sesión, por lo que cada línea que añade es una línea que compite por la atención en las tareas que no tiene nada que ver con.

Regla general: mantener CLAUDE.md bajo 200 líneas. Un CLAUDE.md que carga en el lanzamiento todavía se carga en su totalidad (hasta 4 MiB; Claude Code omite un archivo más grande), pero la adherencia a las instrucciones se degrada a medida que crece el archivo. Los archivos subdirectorios CLAUDE.md y las reglas de acceso, que se cargan bajo demanda, se cortan en un límite por archivo (v2.1.309): ver Jerarquía de la memoria en Claude Code.

Cuando empieza a crecer, mueve el contenido en lugar de recortar la prosa:

Nota: @path las importaciones organizan un gran CLAUDE.md pero no guardar el contexto — los archivos importados se tiran en el tiempo de carga justo igual. Dividir en reglas de acceso es lo que realmente reduce qué cargas.

/doctor (v2.1.206+) inspecciona su configuración y propone recortes cuando CLAUDE.md ha crecido más allá del punto de utilidad.

No escriba recordatorios de verificación

La orientación más antigua alentó líneas como "siempre ejecutar las pruebas antes de decir que has terminado" o "doble comprobación de su trabajo". Claude Opus 5 y Fable 5 ahora causan una verificación excesiva. — Claude vuelve a comprobar el trabajo que ya era correcto, quemando giros y fichas.

Antrópico eliminó más del 80% del sistema propio de Claude Code para la generación Claude 5 sin regresión medida.El mismo principio se aplica a su CLAUDE.md: prefiere indicar el objetivo y dejar que Claude ejerza juicio sobre enumerar los cheques que debe realizar.

Borrar los recordatorios de verificación de archivos CLAUDE.md existentes dirigidos al Opus 5 o Fable 5. Mantenga los requisitos del proyecto genuinamente no obvios — "las pruebas de integración necesitan que Docker se ejecute" es información, no un recordatorio.

Consejos de gestión de memoria

Elija el nivel de memoria adecuado:

Flujo de trabajo de actualización rápida:

1. Para reglas únicas: Uso /memory para abrir el editor, o preguntar conversacionalmente
2. Para múltiples cambios: Usar /memory para abrir el editor
3. Para la configuración inicial: Usar /init para crear plantilla

Importar las mejores prácticas:

# Good: Reference existing docs
@README.md
@docs/architecture.md
@package.json

# Avoid: Copying content that exists elsewhere
# Instead of copying README content into CLAUDE.md, just import it

Instrucciones de instalación

Configurar memoria del proyecto

Método 1: Utilización /init Comando (recomendado)

La forma más rápida de configurar la memoria del proyecto:

1. Navegue a su directorio de proyectos: bash cd /path/to/your/project

2. Ejecute el comando init en Claude Code: bash /init

3. Claude creará y poblará CLAUDE.md con una estructura de plantilla

4. Personalizar el archivo generado para satisfacer las necesidades de su proyecto

5. Comprometerse con git: bash git add CLAUDE.md git commit -m "Initialize project memory with /init"

Método 2: Creación manual

Si prefiere la configuración manual:

1. Crea un CLAUDE.md en tu raíz de proyecto: bash cd /path/to/your/project touch CLAUDE.md

2. Añádanse las normas del proyecto: • cat de bash > CLAUDE.md • 'EOF' # Configuración del proyecto

## Visión general del proyecto - Nombre: Nombre de su proyecto - Tech Stack: Enumere sus tecnologías - Tamaño del equipo: Número de desarrolladores

## Estándares de desarrollo - Sus estándares de codificación - Convenciones de designación - Requisitos de prueba EOF

1. Comprometerse con git: bash git add CLAUDE.md git commit -m "Add project memory configuration"

Configurar memoria personal

1. Crear directorio ~/.claude: bash mkdir -p ~/.claude

2. Crear personal CLAUDE.md: bash touch ~/.claude/CLAUDE.md

3. Añada sus preferencias: # Mis preferencias de desarrollo

## Sobre mí - Nivel de experiencia: [Tu nivel] - Idiomas preferidos: [Tus idiomas] - Estilo de comunicación: [Tu estilo]

## Preferencias de código - EOF

Configurar memoria específica de directorio

1. Crear memoria para directorios específicos: bash mkdir -p /path/to/directory/.claude touch /path/to/directory/CLAUDE.md

2. Añadir reglas específicas del directorio: «Bash cat» > /path/to/directory/CLAUDE.md «EOF» # [Nombre del directorio] Normas

Este archivo complementa root CLAUDE.md para este directorio. Los archivos de memoria están concatenados, no anulados — Claude Code carga este archivo bajo demanda cuando lee, escribe o edita archivos en este directorio.

## [Normas Específicas] EOF

1. Comprometerse al control de la versión: bash git add /path/to/directory/CLAUDE.md git commit -m "Add [directory] memory configuration"

Verificar la configuración

1. Compruebe las ubicaciones de la memoria: # Memoria raíz del proyecto ls -la ./CLAUDE.md

# Memoria personal ls -la ~/.claude/CLAUDE.md

1. Claude Code cargará automáticamente estos archivos al iniciar una sesión

2. Prueba con Claude Code iniciando una nueva sesión en su proyecto

Documentación oficial

Para obtener la información más actualizada, consulte la documentación oficial de Claude Code:

• Documentación de memoria - Referencia completa del sistema de memoria
• Referencia de órdenes de barra - Todos los comandos incorporados, incluyendo /init y /memory
• Referencia de la CLI - Documentación de interfaz de línea de comandos

Detalles técnicos clave de los documentos oficiales

Carga de memoria:

• CLAUDE.md archivos en y por encima del directorio de trabajo, reglas sin alcance, y el inicio de MEMORY.md cargar automáticamente cuando se lanza Claude Code
• Claude atraviesa hacia arriba desde el directorio de trabajo actual para descubrir archivos CLAUDE.md
• Los archivos Subtree se descubren y cargan contextualmente al acceder a esos directorios

Sintaxis de importación:

• Uso @path/to/file incluir contenido externo (por ejemplo, @~/.claude/my-project-instructions.md)
• Soporta rutas relativas y absolutas (las rutas relativas resuelven en relación con el archivo que contiene la importación, no el directorio de trabajo)
• Importaciones recursivas apoyadas con una profundidad máxima de 4 lúpulo
• Las importaciones externas por primera vez activan un diálogo de aprobación
• No evaluado dentro de los espacios de código o bloques de código
• Incluye automáticamente contenido referenciado en el contexto de Claude

CLAUDE.md Orden de carga (concatenado en contexto, no estricta anulación — véase Jerarquía de la memoria en Claude Code supra):

1. Política administrada (carga primero)
2. Normas de nivel de usuario (~/.claude/rules/)
3. Memoria de usuario
4. Normas del proyecto (.claude/rules/)
5. Memoria del proyecto
6. Memoria de proyecto local (loads last)

La memoria automática es un mecanismo separado (~/.claude/projects/<project>/memory/), no es parte de esta orden de concatenación.

Enlaces a conceptos relacionados

Puntos de integración

• Protocolo MCP - Acceso de datos en vivo junto a la memoria
• Comandos de barra - Accesos directos específicos de la sesión
• Skills - Flujos de trabajo automatizados con contexto de memoria

Características relacionadas de Claude

• Memoria web de Claude - Síntesis automática
• Documentos oficiales de memoria - Documentación antropogénica

Última actualización: 26 de octubre de 2026 Versión de Claude Code: 2.1.310 Fuentes: - https://code.claude.com/docs/en/memory - https://code.claude.com/docs/en/memory#agents-md - https://code.claude.com/docs/en/memory#when-agents-md-support-is-unavailable - https://github.com/anthropics/claude-code/releases/tag/v2.1.284 - https://github.com/anthropics/claude-code/releases/tag/v2.1.288 - https://github.com/anthropics/claude-code/releases/tag/v2.1.293 - https://code.claude.com/docs/en/sub-agents#enable-persistent-memory - https://code.claude.com/docs/en/settings-reference - https://code.claude.com/docs/en/claude-directory - https://code.claude.com/docs/en/memory#deploy-organization-wide-claude-md - https://code.claude.com/docs/en/memory#exclude-specific-claude-md-files - https://code.claude.com/docs/en/changelog#2-1-309 - https://code.claude.com/docs/en/memory#claude-ignores-the-end-of-my-subdirectory-claude-md - https://code.claude.com/docs/en/memory#how-it-works - https://code.claude.com/docs/en/memory#path-specific-rules - https://code.claude.com/docs/en/memory#how-claude-md-files-load Modelos compatibles: Claude Fable 5, Claude Opus 5, Claude Sonnet 5, Claude Sonnet 4.6, Claude Opus 4.8, Claude Haiku 4.5