Cómo elegir herramientas de memoria de código: code-review-graph, codebase-memory-mcp, Claude.md y Codex Skills

Mucha gente dice que un AI Agent necesita “memoria del código”. Pero esa frase es demasiado amplia. Algunos quieren que el Agent recuerde reglas del proyecto. Otros quieren que encuentre cadenas de llamadas. Otros no quieren que escanee todo el repositorio cada vez. Y otros quieren que ejecute un flujo fijo de revisión.

Esos cuatro problemas se parecen, pero requieren herramientas diferentes. Claude.md y AGENTS.md son archivos de reglas del proyecto. code-review-graph se parece más a un grafo de relaciones de código y ayuda para revisión. codebase-memory-mcp es un servicio de índice compartido entre herramientas. Codex Skills son instrucciones reutilizables de flujo de trabajo.

Elegir mal no solo reduce funciones. También aumenta el coste de mantenimiento. Este artículo no repite tutoriales de una sola herramienta. Es una guía de decisión.

Conclusión Rápida

Para proyectos pequeños, empieza con AGENTS.md o Claude.md. Para proyectos medianos, añade Codex Skills y fija los flujos repetidos. Para revisión de código, mira primero code-review-graph. Cuando varias herramientas necesiten compartir el mismo índice de código, considera codebase-memory-mcp.

No instales las cuatro cosas al principio. El mejor orden es: reglas, flujos, índice estructural y por último servicio MCP. Si ya leíste comparación de herramientas de memoria para AI Agent, este artículo funciona como una tabla de decisión más práctica.

Cuatro Herramientas, Cuatro Problemas

La clave es el problema principal. No son cuatro marcas de la misma herramienta. Son cuatro capas. La capa de reglas dice al Agent cómo trabajar. La capa de flujo dice qué proceso repetir. La capa estructural dice cómo se conecta el código. La capa de servicio permite que distintos Agents consulten el mismo índice.

Identifica Qué Memoria Falta

Antes de elegir, pregunta:

• ¿El Agent olvida las reglas del proyecto?
• ¿No encuentra código relacionado?
• ¿Repite siempre los mismos pasos?
• ¿El contexto no está sincronizado entre herramientas?

Si solo olvida reglas, escribe AGENTS.md. Si solo repite un flujo, escribe una Skill. Si pierde cadenas de llamadas e impacto, usa un grafo de código. Si Codex, Claude Code y Cursor necesitan el mismo índice estructurado, conecta MCP.

No mezcles todo solo porque la palabra “memoria” suena bien.

Claude.md y AGENTS.md: Reglas del Proyecto

El valor de Claude.md y AGENTS.md está en que sean cortos. Deben decirle al Agent reglas estables, no guardar una enciclopedia del proyecto.

Contenido adecuado:

• Comandos de arranque.
• Comandos de test.
• Estilo de código.
• Directorios que no se deben modificar.
• Chequeos antes de publicar.
• Errores frecuentes.
• Límites de seguridad.
• Requisitos de idioma y redacción.

Contenido inadecuado:

• Contexto completo del negocio.
• Notas antiguas de discusiones.
• Descripción detallada de cada módulo.
• Documentos largos de diseño.
• Logs de tareas puntuales.
• Preferencias personales no verificadas.

Un buen archivo de reglas es una señal. Recuerda al Agent por dónde no debe ir. No debe convertirse en un manual enorme. Para ajustarlo, lee Claude.md no mejora por ser más largo.

Codex Skills: Memoria de Flujo

Una Skill no es un índice de código. Recuerda “cómo se hace el trabajo”.

Por ejemplo, el flujo de nuevo artículo de este sitio incluye:

• Decidir si es un artículo nuevo.
• Encontrar el siguiente número.
• Crear solo index.zh-cn.md.
• Configurar front matter.
• Controlar la fecha de publicación.
• Revisar el número de líneas.
• No generar otros idiomas.

Estos pasos no deberían escribirse en cada prompt. Encajan mejor en una Skill.

Tareas Adecuadas para Skills

• Flujos de publicación.
• Traducción multilingüe.
• Despliegue.
• Revisión de cooldown SEO.
• Reescritura local.
• Listas de seguridad.
• Informes de formato fijo.
• Pasos de revisión de código.

Tareas No Adecuadas

• Depuración puntual.
• Flujos aún exploratorios.
• Tareas con mucho juicio caso por caso.
• Tareas sin criterios de aceptación estables.
• Colecciones de prompts solo para alargar respuestas.

La mejor Skill explica poco y restringe mucho. Debe reducir la probabilidad de que el Agent repita errores fijos. Para escribir una desde cero, lee cómo escribir tu propio flujo con Codex Skills.

code-review-graph: Impacto de Cambios

code-review-graph no intenta recordar el historial de chat. Se centra en la estructura del código. Con una visión de grafo ayuda a responder:

• ¿Quién llama a esta función?
• ¿Qué módulos afecta esta ruta?
• ¿Qué cadenas de llamadas cambió este PR?
• ¿Qué tests conviene añadir?
• ¿Qué archivos deben revisarse juntos?

Estas preguntas son difíciles de responder de forma estable con prompts normales. Si el Agent solo lee el diff, puede perder impacto indirecto. Si busca en todo el repo, desperdicia contexto.

El valor del grafo está ahí. Calcula la estructura por adelantado. El Agent consulta cuando lo necesita.

Para Quién Encaja code-review-graph

• Personas que revisan PRs a menudo.
• Repos con llamadas complejas entre módulos.
• Equipos que quieren que Codex o Claude Code revisen impacto.
• Personas que no quieren escanear todo el repo cada vez.
• Equipos que quieren conectar la revisión a GitHub Actions.

Para Quién No Encaja

• Scripts pequeños con pocos archivos.
• Proyectos sin PR ni diff.
• Usuarios que solo quieren memoria de chat.
• Equipos que no quieren mantener índices.
• Repos que no separan código fuente y archivos generados.

Para empezar, lee cómo usar code-review-graph. Para CI, lee code-review-graph con GitHub Actions.

codebase-memory-mcp: Índice Compartido

codebase-memory-mcp encaja mejor en entornos con varias herramientas. Si solo usas un Agent, quizá no lo necesitas.

Pero si usas Codex, Claude Code, Cursor y Gemini CLI a la vez, aparecen problemas. Cada herramienta tiene su propio contexto. Cada herramienta puede volver a escanear código. Cada herramienta puede entender la estructura de forma distinta.

Ahí un índice de código vía MCP tiene valor. Expone la estructura del repo como un servicio para distintos Agents. El Agent no necesita reconstruir la comprensión cada vez.

Casos Adecuados

• Repos grandes.
• Repos multilenguaje.
• Varios Agents compartiendo un proyecto.
• Índice local-first.
• Acceso unificado vía MCP.
• Reducción del coste de escaneo repetido.

Antes de Usarlo

Es un servicio. Un servicio tiene estado de ejecución. También tiene puertos, permisos, directorios indexados y actualizaciones.

Si nadie lo mantiene, puede convertirse en algo que “se instaló una vez y nadie toca”. Encaja en equipos que ya tienen hábitos estables con Agents. No encaja cuando todavía estás probando. Para instalarlo, lee tutorial de codebase-memory-mcp.

Elegir por Tamaño del Repo

El tamaño del repo cambia la decisión. Un repo de scripts y un monorepo grande no deberían usar la misma memoria.

Menos de 10 Archivos

No necesitas memoria compleja. Mantén:

• README.md.
• AGENTS.md.
• Comandos básicos de test.
• Revisión de Git diff.

Si el Agent aún no encuentra archivos, normalmente la tarea está descrita de forma demasiado amplia.

10 a 200 Archivos

Empieza a hacer falta estructura ligera. Añade:

• Notas de directorios de módulos.
• Lista de comandos frecuentes.
• Una Skill de desarrollo o publicación.
• code-review-graph si hace falta.

El archivo de reglas debe seguir siendo corto. No metas cada módulo en AGENTS.md.

200 a 2000 Archivos

Empiezan los problemas de impacto. Añade:

• Grafo de llamadas.
• Revisión de impacto.
• Estrategia mínima de tests en CI.
• Reglas compartidas de equipo.
• Configuración para excluir directorios generados.

code-review-graph gana valor en esta capa. Ayuda a que el Agent adivine menos.

Repos Grandes Multilenguaje

Necesitan índice compartido y capacidad de servicio. Añade:

• codebase-memory-mcp.
• Configuración MCP unificada.
• Estrategia de actualización del índice.
• Listas de permisos.
• Monitorización del servicio.
• Registro de actualizaciones.

Aquí la herramienta ya es infraestructura. No puede depender solo de hábitos personales.

Elegir por Tipo de Tarea

Cada tarea necesita memoria diferente.

Arreglar Bugs

Los bugs necesitan reproducción y archivos relacionados. Prioridad:

• Logs de error.
• Comandos de reproducción.
• Cambios recientes.
• Tests relacionados.
• Relaciones de llamadas.

Si el bug es local, MCP no hace falta. Si cruza módulos, usa un grafo.

Crear Funciones

Las funciones nuevas necesitan límites. Prioridad:

• Alcance.
• Áreas fuera de alcance.
• Estructuras de datos.
• Contratos API.
• Entradas de test.

Las reglas evitan que el Agent cambie arquitectura sin control. Las Skills guardan el proceso fijo de implementación.

Code Review

La revisión necesita impacto de cambios. Prioridad:

• diff.
• llamadores.
• llamados.
• rutas de entrada.
• cobertura de tests.
• límites de seguridad.

Aquí code-review-graph encaja mejor que un prompt largo.

Documentación y Publicación

Documentación y publicación necesitan memoria de flujo. Prioridad:

• front matter.
• nombres de archivos.
• reglas de build.
• sincronización multilingüe.
• revisión de enlaces.
• chequeo de publicación.

Este tipo de trabajo encaja mejor con Skills.

Estrategia de Actualización

La memoria del código engaña al Agent si queda vieja. Cada herramienta se actualiza de forma distinta.

Los archivos de reglas se mantienen manualmente. Las Skills se actualizan cuando cambia el flujo. code-review-graph debe reconstruirse o actualizarse tras cambios de código. codebase-memory-mcp requiere mantener el servicio y los datos del índice.

Cuándo Actualizar

• Nuevos módulos.
• Directorios eliminados.
• Cambios de rutas.
• Cambios de comandos de test.
• Cambios de herramienta de build.
• Cambios de directorios generados.
• Cambios de permisos de equipo.
• Cambios de CI.
• Actualizaciones de herramientas Agent.
• Actualizaciones del servicio MCP.

Validación Posterior

• El Agent puede explicar archivos de entrada.
• Puede encontrar tests relacionados.
• No escanea directorios generados.
• Puede explicar un diff real.
• Respeta áreas prohibidas.
• Llama a la Skill correcta.
• MCP devuelve archivos actuales.
• El grafo coincide con el código real.

Fallos Típicos

Archivo de Reglas Demasiado Largo

Síntoma: el Agent lee lento y cita reglas irrelevantes. Solución: recortar. Mantén restricciones estables. Mueve flujos a Skills. Mueve contexto a documentación.

Skill Demasiado Amplia

Síntoma: cada tarea se fuerza al mismo flujo. Solución: dividir. Una Skill debe servir a un tipo de trabajo. Por ejemplo, separa publicación, traducción, despliegue y revisión.

El Grafo Incluye Directorios Generados

Síntoma: el Agent mira artefactos de build en vez de código fuente. Solución: actualizar ignore. Excluye dist/, public/, node_modules/ y cachés.

MCP con Permisos Demasiado Amplios

Síntoma: el Agent puede acceder a demasiados recursos no relacionados. Solución: separar niveles. Primero herramientas de solo lectura. Herramientas de escritura con aprobación separada. Herramientas de producción cerradas por defecto.

Cómo Combinarlas

Para proyectos personales pequeños: AGENTS.md, poca documentación, Git diff y el comando mínimo de test. Para proyectos web medianos: AGENTS.md, una Skill de publicación o test, code-review-graph y una plantilla de PR review. Para equipos con varios Agents: AGENTS.md, Skills de equipo, code-review-graph, codebase-memory-mcp, revisión en CI y documentación de permisos. Para sitios de contenido y automatización: Skill de publicación, Skill de traducción, reglas de cooldown SEO, Skill de despliegue y una pequeña nota de estructura del sitio.

La clave no es tener muchas herramientas. La clave es que cada capa resuelva un problema distinto.

Árbol de Decisión

Primero pregunta: ¿el Agent viola reglas del proyecto con frecuencia? Si sí, escribe AGENTS.md o Claude.md.

¿Repite la misma secuencia de pasos? Si sí, escribe una Skill.

¿Pierde cadenas de llamadas o alcance de impacto? Si sí, usa code-review-graph.

¿Varios Agents necesitan compartir el mismo índice? Si sí, considera codebase-memory-mcp.

Si no, no añadas herramientas todavía. Este orden evita complicar problemas simples.

Cómo Conectar Artículos Existentes

Este artículo sirve como entrada de selección. Los tutoriales concretos quedan en artículos existentes.

Los comandos de code-review-graph están en 7/99. La integración con GitHub Actions está en 7/137. La instalación de codebase-memory-mcp está en 6/113. La filosofía de archivos de reglas está en 4/118. La ruta general de memoria está en 7/42.

Así el lector no queda enterrado bajo todos los comandos en un solo artículo. Primero elige dirección y luego entra al tutorial concreto.

Recomendación Final

Si solo quieres que el Agent evite errores fijos, elige AGENTS.md o Claude.md. Si quieres que siga un proceso fijo, elige Codex Skills. Si quieres análisis de impacto de cambios, elige code-review-graph. Si quieres que varios Agents compartan estructura de código, elige codebase-memory-mcp.

La memoria madura del código no consiste en recordarlo todo. Consiste en poner reglas, flujos, estructura y servicios en el lugar correcto.