Estructura de folders y archivos para Claude: tu segundo cerebro sin base de datos

Cada semana sale alguien diciendo que para que Claude funcione de verdad tienes que montarle un segundo cerebro: una base de datos vectorizada, todo Obsidian conectado, embeddings, RAG. Suena impresionante y da la sensación de que sin eso vas atrasado. La verdad es más aburrida y más liberadora: la mayoría no necesita nada de eso.

Para código y proyectos normales, los agentes como Claude Code ya saben buscar solos: leen el árbol de carpetas, abren archivos por su nombre y hacen búsquedas de texto. A eso se le llama agentic search, y para el 95% de los casos basta. El consenso en 2026 es claro: empieza con esa búsqueda y agrega búsqueda semántica solo el día que de verdad la necesites.

Entonces, ¿qué le falta a tu agente para no empezar de cero cada vez? Estructura. Carpetas ordenadas y unos archivos de texto que le digan dónde está todo y qué aprendiste. Eso es lo que vamos a armar aquí. Si más adelante te quedas corto, hay herramientas de memoria de verdad en la guía de memoria infinita para Claude Code.

El primer archivo que pones en tu carpeta se llama CLAUDE.md. Es un archivo de texto que tú escribes y que Claude lee automáticamente al inicio de cada sesión, como contexto que no se borra. Ojo: no es configuración que se ejecuta ni código, es una nota para tu agente. Va en la raíz, el nivel de más arriba de tu proyecto.

Así de simple se ve un CLAUDE.md raíz —fíjate que es texto plano, nada más:

# Mi proyecto

App de notas para equipos pequeños.

## Comandos
- Correr: npm run dev
- Probar: npm test

## Dónde vive cada cosa
- src/  → código de la app
- docs/ → guías y notas

Con eso, cuando abres Claude, ya sabe qué es el proyecto, cómo correrlo y dónde mirar. No adivina. Lo importante son los comandos —cómo se corre y se prueba— y el mapa de carpetas.

La idea completa cabe en una imagen. Arriba, en la raíz, va el CLAUDE.md que hace de mapa. Abajo, una carpeta por tema o proyecto, y dentro de cada una su propio CLAUDE.md con las reglas de ese rincón. Así:

mi-proyecto/
├── CLAUDE.md          ← el mapa: dónde está todo
├── clientes/
│   └── CLAUDE.md      ← reglas de esta carpeta
├── facturas/
│   └── CLAUDE.md      ← reglas de esta carpeta
└── notas/
    └── CLAUDE.md      ← reglas de esta carpeta

El CLAUDE.md de cada carpeta no repite lo de la raíz: solo dice qué hay ahí y cómo se trabaja en ese tema. Es como pegar una nota en la puerta de cada cuarto.

Resultado: un agente que llega a cada carpeta sabiendo de qué va, sin cargar de más y sin que tú tengas que repetirle el contexto cada sesión.

¿No quieres escribir el primer CLAUDE.md a mano? No hace falta. Dentro de Claude Code escribes /init y él revisa tu proyecto solo, entiende de qué va y te genera un CLAUDE.md inicial.

En ese primer archivo te deja el stack, los comandos de correr y probar, y un resumen de la estructura. Si ya tenías un CLAUDE.md, no lo pisa: te sugiere mejoras. Tú lo lees, ajustas lo que no cuadre y listo. De adivinar a tener un mapa en menos tiempo del que tardas en buscar dónde iba cada cosa.

Con /init ya tienes la raíz. El siguiente paso es bajar a las carpetas, y para eso te dejamos los prompts listos para copiar.

No tienes que escribir nada de esto a mano. Copia el prompt, pégalo en Claude y deja que él haga el trabajo. Van en orden: primero diseñas las carpetas, luego el mapa de la raíz, después las reglas de cada carpeta y al final el que lo mantiene vivo.

Quiero organizar este espacio de trabajo para que tú, Claude, te ubiques solo cuando volvamos a trabajar.

Propón una estructura de carpetas simple: una carpeta por tema o por proyecto, con nombres claros, sin anidar de más. Para cada carpeta dime en una línea qué iría dentro.

No instales nada ni inventes una base de datos. Solo carpetas y archivos de texto. Cuando tenga el árbol claro, espera mi OK antes de crear nada.

Crea el CLAUDE.md de la raíz de este proyecto. Es el mapa que vas a leer al inicio de cada sesión, así que tiene que ser corto y útil. Máximo 60 líneas.

Incluye, en este orden:
1. Un párrafo de 2-3 líneas: qué es este proyecto y para quién.
2. El stack o las herramientas principales.
3. Los comandos clave: cómo se corre, cómo se prueba, cómo se revisa.
4. Dónde vive cada cosa (qué hay en cada carpeta).
5. 3 o 4 reglas concretas de "haz esto / no hagas esto".

Sé específico, no vago: "usa 2 espacios de indentación" en vez de "formatea bonito".

Crea un CLAUDE.md dentro de la carpeta [NOMBRE DE LA CARPETA].

Son las reglas locales de esta carpeta nada más. No repitas lo que ya está en el CLAUDE.md de la raíz.

Explica en pocas líneas: qué hay en esta carpeta, cómo se nombran los archivos aquí, qué convenciones aplican solo aquí y qué NO se debe tocar. Máximo 30 líneas y al grano.

Antes de terminar, actualiza los CLAUDE.md con lo que aprendimos en esta sesión, para que la próxima vez no empieces desde cero.

Revisa qué decisiones tomamos, qué convención nueva quedó o qué error evitamos, y guárdalo como una regla corta en el CLAUDE.md que corresponda (raíz o carpeta). No infles el archivo: agrega solo lo que de verdad te ahorraría tiempo la próxima vez, y bórrame lo que ya quedó obsoleto.

Con estos cuatro armas la estructura completa sin tocar una línea de código tú. Recuerda pedirle a Claude que espere tu OK antes de crear archivos, así revisas el árbol antes de que lo escriba.

Cuando un CLAUDE.md empieza a crecer, no hace falta meterlo todo en un archivo. Puedes incluir otros con la sintaxis @ruta/al/archivo dentro del CLAUDE.md. Es como decir “y aquí también lee este otro”. Sirve para separar las reglas por tema y mantener cada archivo legible. Soporta hasta unos cuatro saltos anidados.

¿No sabes por qué una regla no se aplica? El comando /memory te lista todos los CLAUDE.md que Claude tiene cargados en ese momento y te deja editarlos. Es tu panel para ver qué está leyendo de verdad y arreglar lo que falte.

Lo último y lo más importante: el archivo tiene que vivir. Cuando termines una sesión, pide a Claude que guarde lo aprendido —una decisión, una convención, un error que evitar— en el CLAUDE.md que corresponda. Así, la próxima vez no arranca de cero. Ese ciclo de mejorar las reglas solo está en la guía de feedback loop.