Everything Claude Code (ECC): el framework de agentes open source para Claude Code

Desde que los agentes de programación se popularizaron, ¿cuántas veces has vuelto a explicar tu stack, convenciones, preferencias y criterios de revisión al empezar cada sesión?

El problema es que cada conversación empieza en frío. Herramientas como Claude Code saben escribir código, pero no saben cómo escribe código tu equipo. Lo que empezó como un ahorro de tiempo termina en trabajo manual: pegar siempre el mismo contexto del proyecto, corregir al modelo cuando se desvía, optimizar instrucciones y revisar las mismas sugerencias genéricas una y otra vez.

Everything Claude Code (ECC) es un framework open source que aspira a solucionarlo. A pesar del nombre, no tiene relación con Anthropic. Es un sistema de agentes y una capa de flujos de trabajo que se ejecuta sobre Claude Code (no es un modelo ni un IDE) y convierte un agente genérico en una plataforma de ingeniería especializada que ya conoce tus estándares.

En este artículo, verás qué es ECC, cómo encajan sus piezas, cómo instalarlo y para quién realmente tiene sentido.

Pero ¿qué es exactamente Claude Code? Apúntate a nuestro curso Claude Code 101 para aprender a usarlo en tus flujos de desarrollo diarios.

¿Qué es Everything Claude Code?

ECC es un repositorio open source que envuelve Claude Code con una capa operativa preconstruida para trabajo de ingeniería.

Puedes encontrar el proyecto en affaan-m/ECC en GitHub. Tiene licencia MIT, lo mantiene Affaan Mustafa y nace de más de 10 meses de uso diario de Claude Code en productos reales. No está afiliado a Anthropic, pese al nombre.

El repo empaqueta cuatro cosas en una sola instalación:

• Un arnés de agentes: un conjunto de subagentes especializados (planificador, arquitecto, revisor de código, revisor de seguridad, solucionador de errores de build y una docena más) a los que Claude Code delega en lugar de intentar hacer todo en una sola ventana de contexto.
• Un ecosistema de habilidades: varios cientos de definiciones de flujo pequeñas que cubren TDD, revisión de seguridad, patrones de frameworks (Django, Spring Boot, Next.js y otros), estándares de código por lenguaje y tareas de ingeniería de ML.
• Un framework de flujos: hooks que se ejecutan en eventos de herramientas, reglas que siempre aplican, configuraciones de servidores MCP y memoria de sesión que persiste entre conversaciones.
• Una capa de comandos: entradas con barra mantenidas para ejecutar flujos habituales, más una carpeta shim retrocompatible para nombres de comandos antiguos.

Es importante tener claro que Claude Code sigue siendo el motor. Lee el código y ejecuta las herramientas.

El trabajo de ECC es todo lo que rodea a eso: decirle a Claude Code qué subagente debe encargarse de una tarea, qué pasos de flujo seguir, qué convenciones usa tu stack y qué contexto arrastrar de la sesión de ayer.

En la práctica, ya no necesitas configurar Claude Code desde cero para cada proyecto. Instalas ECC una vez, copias los paquetes de reglas de tu stack y ya tienes una plataforma de ingeniería especializada que sabe cómo proceder.

Por qué Everything Claude Code se ha vuelto tan popular

El crecimiento empezó con un hilo en X.

A principios de 2026, Mustafa publicó The Shorthand Guide to Everything Claude Code. Consiguió más de 10.000 marcadores en pocos días. Después abrió el repo, y ECC ya ha superado las 200.000 estrellas y 34+ forks.

Esto es lo que lo explica:

• La programación con agentes pasó de experimento a uso diario: A medida que más desarrolladores empezaron a usar Claude Code, se hicieron visibles las limitaciones del sistema base. Lo que hacía falta era una capa de configuración previa que eliminase el arranque en frío, las salidas inconsistentes de revisión de código y similares.
• Redactar buenos prompts para agentes es más difícil de lo que parece: Un flujo TDD sólido o un prompt de revisor de código que filtre por confianza requiere iteración. Muchos equipos no quieren construir y mantener eso desde cero a medida que cambian los modelos, así que reutilizar una versión ya probada de terceros es la vía fácil.
• Se acumularon contribuciones: más de 270 colaboradores han añadido paquetes de reglas por lenguaje (Java, Kotlin, Rust, Perl, PHP), soporte de frameworks (Quarkus, Laravel), traducciones, integraciones con IDE más allá de Claude Code (Cursor, OpenCode, Zed) y nuevas habilidades.
• ECC aporta especialización sin fine-tuning: Ajustar un modelo a las convenciones del equipo no es práctico para la mayoría. Un conjunto estructurado de habilidades y agentes en tiempo de ejecución se acerca bastante al mismo efecto, y ECC es uno de los intentos más completos de empaquetarlo.

Así que empezó con un hilo en X y a partir de ahí el efecto bola de nieve.

Cómo funciona Everything Claude Code

ECC es un sistema por capas.

Hay cinco componentes entre tú y tu base de código. Claude Code es el runtime. Habilidades, agentes, MCP y una capa de memoria lo envuelven. Cada pieza hace una función, y se pasan trabajo entre sí durante la sesión.

Claude Code

Claude Code es la interfaz del modelo subyacente.

Es el CLI oficial de Anthropic para ejecutar Claude como agente de programación. Lee archivos, escribe diffs, lanza comandos de shell, llama a herramientas y sostiene la conversación. ECC no sustituye nada de eso. Todo lo que añade ECC se carga en Claude Code al inicio de la sesión y funciona a través de su sistema de plugins, hooks y comandos.

Habilidades

Las habilidades son instrucciones de flujo reutilizables guardadas como archivos Markdown.

Cada habilidad es una carpeta pequeña con un SKILL.md que le dice a Claude Code cómo manejar un tipo concreto de tarea. La habilidad define la descripción, los pasos, el output esperado y las restricciones. ECC tiene alrededor de 260 habilidades que cubren patrones por lenguaje, flujos de test, convenciones de frameworks, ingeniería de ML y tareas operativas.

Recuerda que no ejecutas habilidades manualmente. Claude Code las elige según lo que estés haciendo, o las referencias en un prompt.

Agentes

Los agentes son subagentes especializados a los que Claude Code delega.

Cada uno se define en Markdown con un nombre, una descripción, una lista blanca de herramientas y un prompt de sistema que acota su comportamiento. El agente code-reviewer solo lee archivos e informa hallazgos. El planner escribe planos de implementación antes de tocar código. Ya te haces una idea.

El objetivo de esta división es aislar el contexto. Cada subagente recibe una ventana de contexto limpia para su tarea, así la sesión principal no se satura. El agente principal coordina y los subagentes ejecutan.

Integraciones MCP

MCP (Model Context Protocol) es cómo Claude Code habla con herramientas y fuentes de datos externas.

ECC trae configuraciones para conectar con GitHub, Supabase, Vercel, Railway y otros mediante servidores MCP. Cada servidor expone herramientas que Claude Code puede llamar en mitad de la sesión. ECC simplemente empaqueta configuraciones funcionales y reglas de seguridad para ellos.

Por defecto ECC activa un solo conector (chrome-devtools). El resto es opt-in, lo que evita colisiones de nombres de herramientas y mantiene reducida la superficie de ataque.

Capa de memoria

La capa de memoria hace que ECC conserve estado entre sesiones.

Se ejecutan hooks en el evento Stop de cada conversación y escriben un resumen de sesión en ~/.claude/sessions/. La siguiente sesión carga el contexto relevante al inicio mediante un hook SessionStart. Las habilidades que el modelo "aprende" de tus patrones se extraen al sistema Continuous Learning v2, donde se guardan como instintos con puntuaciones de confianza y se pueden reutilizar.

Alias de sesión, habilidades aprendidas y métricas viven bajo una única raíz de datos del agente (por defecto ~/.claude, configurable por arnés si ejecutas ECC tanto en Claude Code como en Cursor).

Cómo encajan las piezas

Una sesión típica se ve así:

1. Inicio de sesión: un hook carga el contexto de la sesión anterior, más habilidades y reglas relevantes para el proyecto actual.
2. Pides algo: por ejemplo, "añade login con OAuth".
3. Primero corre el agente planner: escribe un plano; aún no hay código.
4. Entra la habilidad TDD: Claude Code sigue el flujo de test que falla, implementación mínima y refactor.
5. Se llaman herramientas MCP: quizá el MCP de GitHub trae PRs relacionados, o el de Supabase comprueba el esquema.
6. Al final corre el agente code-reviewer: audita el diff en su propia ventana de contexto e informa.
7. Cierre de sesión: un hook Stop escribe un resumen, extrae nuevos patrones como instintos y los guarda para la próxima vez.

El modelo sigue siendo Claude Code. ECC solo orquesta qué habilidad, qué agente y qué herramienta se usa en cada paso.

Habilidades en Everything Claude Code

Las habilidades son la vía principal con la que ECC le dice a Claude Code qué hacer.

Una habilidad es una carpeta con un archivo SKILL.md. El Markdown define la descripción, los pasos, las restricciones, el resultado esperado y los contextos en los que aplica. Es un simple archivo de texto que el modelo lee en tiempo de ejecución.

Y es así a propósito. ECC no "reentrena" nada: carga instrucciones que Claude lee y sigue en el momento.

Las habilidades viven en el directorio skills/ en la raíz del repo. Tras la instalación, se copian a ~/.claude/skills/. Claude Code las carga como hijas directas de esa carpeta.

Cada carpeta de habilidad tiene el mismo esquema básico:

• SKILL.md - la definición del flujo
• Archivos de apoyo opcionales (plantillas, scripts, ejemplos)
• Un metadata.yaml opcional para etiquetado y descubrimiento

Las habilidades influyen en el comportamiento de los agentes de dos formas. Primero, Claude Code las lee al iniciar la sesión y las mantiene disponibles como referencia. Segundo, el modelo selecciona la habilidad relevante según lo que pidas. Si dices "escribe primero un test que falle", se activa la habilidad TDD. Si dices "revisa esto por inyección SQL", se activa la habilidad de revisión de seguridad.

ECC incluye unas 260 habilidades. Estas muestran el abanico:

• frontend-patterns: convenciones de React y Next.js. Estructura de componentes, uso de hooks, decisiones server vs. client components, patrones de estado.

• django-patterns, django-tdd, django-security, django-verification: una pila Django completa dividida en cuatro habilidades. Una para arquitectura, otra para el ciclo de tests, otra para auditorías al estilo OWASP y otra para el bucle de verificación previa al envío.

• architect (emparejada con el agente architect): revisiones de diseño de sistemas. La habilidad define qué cubre una revisión de arquitectura, qué artefactos produce y qué trade-offs destacar.

• tdd-workflow: el ciclo rojo–verde–refactor. Escribe el test que falla, el mínimo código para pasarlo, refactoriza y verifica cobertura. La habilidad fuerza el orden.

• security-review: checklist de auditoría OWASP Top 10, detección de credenciales hardcodeadas, revisión de validación de entradas y comprobación de vulnerabilidades de dependencias. La habilidad define qué escanear y qué señalar.

Agentes en Everything Claude Code

Los agentes son “personas” especializadas con su propia ventana de contexto.

Cada uno es un archivo Markdown en la carpeta agents/ con un nombre, una descripción, una lista blanca de herramientas y un prompt de sistema. El prompt de sistema define el cometido del agente. La lista blanca controla lo que puede hacer (leer archivos, ejecutar bash, llamar servidores MCP, escribir código). Claude Code delega tareas a un agente automáticamente por ti.

ECC tiene 66 agentes, agrupados en varias categorías.

Agentes de planificación que se ejecutan antes de escribir código.

El agente planner descompone una petición de funcionalidad en un plano de implementación: archivos a cambiar, interfaces a definir, tests a escribir y casos límite a cubrir. El agente architect va a un nivel superior: diseño del sistema, modelo de datos, límites de servicios. Estos agentes solo leen código y escriben planes.

Agentes de codificación que realizan la implementación.

El tdd-guide fuerza el ciclo de tests primero. Resolutores por lenguaje como go-build-resolver, pytorch-build-resolver y kotlin-build-resolver arreglan errores de build en sus ecosistemas. El refactor-cleaner elimina código no usado.

Agentes de arquitectura que revisan decisiones estructurales.

El architect cubre el diseño, el database-reviewer los patrones de consultas y decisiones de esquema, y el mle-reviewer audita pipelines de ML en producción (contratos de datos, cobertura de evaluación, serving, monitorización).

Agentes de QA que verifican lo construido.

El code-reviewer audita diffs por calidad y seguridad con un umbral de confianza. El security-reviewer ejecuta un pase al estilo OWASP. El e2e-runner maneja tests end-to-end con Playwright. Los revisores por lenguaje (typescript-reviewer, python-reviewer, go-reviewer, rust-reviewer y otros) cubren comprobaciones específicas.

El motivo de dividirlo en agentes separados es el aislamiento del contexto.

Cuando corre el code-reviewer, recibe una ventana de contexto nueva con solo el diff y la habilidad de revisión cargados. No ve las notas de planificación ni el historial de conversación. Solo revisa. Ese foco produce mejores resultados que pedir a un único agente generalista que planifique, codifique, pruebe y revise en el mismo contexto, que es lo que acaban haciendo muchos montajes ad hoc de Claude Code.

Gestión de contexto y memoria en ECC

ECC no lo olvida todo entre sesiones como hace Claude Code.

La memoria en ECC es un sistema de hooks que escriben archivos en los momentos adecuados y los cargan cuando toca. Son simples archivos Markdown y JSON en disco.

Persisten tres cosas:

1. Se escriben resúmenes al terminar la sesión: un hook Stop corre tras el último mensaje, toma la transcripción completa y escribe un resumen en ~/.claude/sessions/. Cubre en qué se trabajó, qué se decidió y qué queda abierto. La próxima sesión lo lee durante un hook SessionStart para retomar donde lo dejaste.
2. Los instintos son patrones extraídos de tus sesiones: el sistema Continuous Learning v2 observa lo que haces y lo que funciona, y escribe instintos con una puntuación de confianza, una acción, evidencias y ejemplos. Ejecuta /instinct-status para ver qué se ha aprendido. Ejecuta /evolve para agrupar instintos relacionados y crear una habilidad nueva.
3. Los logs rastrean la capa operativa: ejecuciones de hooks, ejecuciones de habilidades, llamadas MCP, costes, errores. Viven en ~/.claude/metrics/ y ~/.claude/session-data/. Útiles para depurar y para el panel GUI que viene con el repo.

Si crees que no es para tanto, aquí tienes un par de motivos que te harán cambiar de opinión:

• Proyectos de larga duración: un refactor de seis meses no se reinicia cada lunes. Las decisiones, trade-offs y problemas conocidos de la semana pasada están en el resumen que se carga al inicio.
• Nada de explicaciones repetidas: no vuelves a pegar tu stack, tus convenciones ni el "recuerda que decidimos usar Postgres, no Oracle" cada vez.
• Sortea los límites de contexto: incluso con una ventana de un millón de tokens, no cabe la historia de un proyecto de seis meses. Los resúmenes comprimen lo importante. La historia completa queda en disco; el modelo recibe lo relevante.

Puedes afinar el contexto cargado con variables de entorno. ECC_SESSION_START_MAX_CHARS limita cuántos caracteres del resumen se cargan al inicio (por defecto 8.000). ECC_SESSION_START_CONTEXT=off lo desactiva para montajes de bajo contexto. ECC_SESSION_RETENTION_DAYS controla cuánto tiempo se conservan las sesiones antes de depurarlas.

Si ejecutas ECC en Claude Code y en Cursor en la misma máquina, ajusta ECC_AGENT_DATA_HOME para separar su memoria. Si no, se sobreescriben los archivos de sesión.

Soporte MCP en Everything Claude Code

MCP es cómo Claude Code llama a cualquier cosa que no sea un archivo o un comando de shell.

Model Context Protocol es el estándar de Anthropic para conectar modelos de lenguaje con herramientas externas. Un servidor MCP corre como proceso separado y expone operaciones tipadas: "lee esta página de Notion" o "abre un PR en GitHub". Claude Code invoca esas operaciones como si fuesen llamadas a funciones.

ECC incluye configuraciones MCP en mcp-configs/mcp-servers.json para servicios comunes: GitHub, Supabase, Vercel, Railway, Linear y otros. Cada entrada incluye el comando para iniciar el servidor, las variables de entorno requeridas y las reglas de seguridad que aplica ECC.

Conviene saber que ECC no los activa automáticamente.

La política de conectores MCP de junio de 2026 redujo los servidores activados por defecto a uno (chrome-devtools). El resto es opt-in. O copias la entrada en el .mcp.json de tu proyecto, o la activas con el comando /mcp de Claude Code. La razón es en parte práctica (nombres largos de herramientas MCP rompen algunas pasarelas) y en parte de seguridad (cada servidor MCP es una posible superficie de ataque).

En la práctica, el soporte luce así:

• Integraciones externas: añade la entrada de GitHub a .mcp.json, proporciona un token y Claude Code podrá leer issues, abrir PRs y consultar el estado del CI sin copiar y pegar.
• Llamada a herramientas: habilidades y agentes referencian herramientas MCP por nombre. Por ejemplo, una habilidad de despliegue puede llamar al MCP de Vercel, y un agente de revisión de bases de datos puede llamar al de Supabase.
• Automatización de proyecto: puedes combinar servidores MCP con hooks para obtener automatización persistente entre sesiones. Un hook al abrir PR puede iniciar un agente revisor que use el MCP de GitHub para traer el diff y el de Linear para actualizar el ticket.

Si ya ejecutas copias propias de MCP que incluye ECC, define ECC_DISABLED_MCPS con una lista separada por comas. ECC omitirá esos durante la instalación y la sincronización para evitar duplicados compitiendo por el mismo nombre.

AgentShield y funciones de seguridad

La seguridad es lo que diferencia a ECC del resto.

AgentShield es un auditor de seguridad independiente que viene con ECC. Escanea configuraciones de Claude Code en busca de vulnerabilidades, configuraciones erróneas, fallos y riesgos de inyección. Se ejecuta como paquete npm separado (ecc-agentshield), pero está conectado a ECC mediante la habilidad /security-scan para que lo lances desde una sesión de Claude Code.

El escaneo cubre cinco categorías:

• Detección de secretos: 14 patrones para credenciales hardcodeadas, API keys, tokens.
• Auditoría de permisos: qué herramientas y rutas puede acceder cada agente y habilidad, y si esos permisos son demasiado amplios.
• Análisis de inyección en hooks: si los hooks pueden explotarse para ejecutar comandos arbitrarios.
• Perfilado de riesgo de servidores MCP: qué puede leer, escribir o llamar cada servidor MCP conectado y dónde crea exposición.
• Revisión de configuración de agentes: vectores de inyección en prompts, listas blancas de herramientas demasiado generosas, restricciones ausentes.

Puedes ejecutarlo con este comando, sin instalación previa:

npx ecc-agentshield scan

La salida es una calificación por letra (de A a F) más una lista de hallazgos ordenados por severidad. Los hallazgos críticos salen con código 2.

Algunas flags útiles:

• -fix aplica arreglos automáticos para problemas seguros (eliminar secretos expuestos, estrechar permisos demasiado amplios…)
• -opus ejecuta el escaneo con tres agentes Claude Opus 4.X en una cadena red-team / blue-team / auditor. El atacante busca cadenas de explotación. El defensor evalúa las protecciones. El auditor sintetiza ambas en un informe priorizado de riesgos.
• -stream transmite el análisis en vivo, útil en configuraciones lentas.

El enfoque con Opus es lo que separa AgentShield de un linter genérico. Agentes adversarios intentan encadenar componentes “correctos” para lograr algo explotable, que es donde ocurren la mayoría de ataques reales a agentes.

Según el repo, AgentShield reporta 102 reglas de análisis estático y 1.282 tests internos con un 98% de cobertura. Conviene verificar las cifras contra la última versión, pero queda claro que no es un script de 50 líneas.

Formatos de salida: terminal (con colores), JSON (para CI), Markdown y HTML. También hay una GitHub Action y una app de GitHub separada (ECC Tools) que ejecuta AgentShield en los PRs.

Para la mayoría de equipos que usan Claude Code en producción, AgentShield es el motivo más tangible para instalar ECC incluso si no usas el resto del framework.

Instalar Everything Claude Code

ECC tiene dos vías de instalación.

El error más común es apilar la instalación por plugin encima de la instalación manual. Ambas copian los mismos archivos en los mismos sitios y acabas con duplicados. Así que, antes de nada: elige solo un camino.

Antes de instalar, asegúrate de tener Claude Code en la v2.1.0 o posterior:

claude --version

Versión de Claude

Instalación vía gestor de plugins

Esta es la vía recomendada para la mayoría.

Desde dentro de Claude Code, ejecuta:

/plugin marketplace add https://github.com/affaan-m/ECC
/plugin install ecc@ecc

Instalación del plugin

El primer comando registra el repo de ECC como marketplace. El segundo instala el plugin.

Un matiz: el sistema de plugins no distribuye reglas. Las reglas son las directrices que siempre se siguen (estilo de código, flujo de git, estándares de testing, patrones por lenguaje) y la especificación de plugins de Claude Code no las incluye. Tienes que copiarlas manualmente tras instalar el plugin.

git clone https://github.com/affaan-m/ECC.git
cd ECC
mkdir -p ~/.claude/rules/ecc
cp -r rules/common ~/.claude/rules/ecc/
cp -r rules/python ~/.claude/rules/ecc/

Copia rules/common más un paquete de lenguaje que uses de verdad. En el ejemplo de arriba, he copiado las reglas de Python. No lo copies todo: más reglas implican más contexto cargado en cada sesión, y gran parte no aplicará a tu proyecto.

Instalación vía archivos de configuración

Usa este enfoque si quieres control total o si el plugin no funciona en tu entorno.

git clone https://github.com/affaan-m/ECC.git
cd ECC
npm install
./install.sh --profile full

En Windows:

.\install.ps1 --profile full
# o
npx ecc-install --profile full

Esto copia agentes, habilidades, comandos, hooks y reglas en tu directorio ~/.claude/. No hay capa de plugin: todo vive como archivos en disco que Claude Code lee al arrancar la sesión.

Algunas opciones de perfil a tener en cuenta:

• -profile minimal: solo reglas, agentes, comandos y habilidades core, sin hooks.

• -profile core: el conjunto por defecto. Incluye hooks.

• -profile full: todo lo del repo.

También puedes instalar componentes concretos con --modules o --with:

./install.sh --target claude --modules hooks-runtime
npx ecc install --profile minimal --target claude --with capability:machine-learning

Si no tienes claro qué componentes encajan con tu trabajo, pregunta al asesor incluido:

npx ecc consult "security reviews" --target claude

Devuelve los componentes que encajan y los comandos exactos para instalarlos.

Verificar la instalación

Comprueba qué se instaló:

/plugin list ecc@ecc

Verificación de instalación del plugin

Eso muestra los agentes, comandos y habilidades disponibles desde el plugin. Para instalaciones manuales, usa el wrapper de ciclo de vida:

node scripts/ecc.js list-installed
node scripts/ecc.js doctor

doctor comprueba archivos faltantes, hooks rotos y desfases de versión. Si detecta algo, ejecuta:

node scripts/ecc.js repair

Para confirmar que Claude Code ve el nuevo plugin, abre una sesión y prueba un comando con barra:

/ecc:plan "Add user authentication"

Salida de plan de ECC

En instalaciones por plugin, el prefijo con espacio de nombres /ecc: es obligatorio. En instalaciones manuales funciona la forma corta (/plan).

Si ves duplicados o algo roto, no reinstales encima. Ejecuta primero node scripts/uninstall.js --dry-run para ver qué se eliminaría y luego node scripts/uninstall.js para limpiar. ECC solo elimina archivos que instaló, así que el resto de tu configuración queda intacta.

Trabajar con habilidades, comandos y flujos

La mayoría de lo que haces en ECC pasa por habilidades más que por comandos.

El motivo es que la carpeta commands/ se sigue manteniendo por compatibilidad hacia atrás, pero el desarrollo de flujos nuevos vive primero en skills/.

Estos patrones de uso cubrirán la mayor parte de tu día a día.

La invocación de habilidades suele ser implícita

No sueles llamar a una habilidad por su nombre. Describes lo que quieres y Claude Code elige la que encaja. Si dices "escribe primero un test que falle", se activará la habilidad tdd-workflow. Los nombres de habilidades aparecen en la respuesta para que veas qué se cargó.

Cuando quieras ser explícito, referencia la habilidad en el prompt: "Usa la habilidad django-tdd para añadir el nuevo endpoint". O ejecuta un comando que la envuelve:

/code-review
/security-scan

/ecc:plan "Add OAuth login"

El prefijo /ecc: es obligatorio en instalaciones por plugin. En instalaciones manuales se usa la forma corta (/plan, /code-review).

Salida de la fase de planificación de ECC

El targeting de archivos forma parte del flujo

La mayoría de agentes y habilidades operan sobre un alcance concreto: un archivo, un directorio, un diff, un PR. Acotas el alcance mencionando el archivo en el prompt, abriéndolo en tu editor antes de invocar o apuntando el agente a una ruta:

/code-review src/auth/
/python-review services/billing/payment.py

El agente toma el alcance, carga solo los archivos necesarios y corre en su propia ventana de contexto.

La integración con shell va por la herramienta bash de Claude Code

Las habilidades pueden salir al shell para todo lo que requiera ejecución real: correr tests, compilar, linting o llamar a un CLI. La habilidad TDD ejecuta pytest o go test. El agente de arreglo de builds ejecuta la build real para ver errores reales. La habilidad de escaneo de seguridad ejecuta npx ecc-agentshield scan y parsea la salida.

La habilidad define qué comandos de shell se ejecutan y cuándo. Los hooks también pueden ejecutar comandos en eventos de herramientas (lanzar un typecheck tras cada edición, avisar de console.log antes de guardar).

La gestión de MCP es mayoritariamente opt-in

Tras la instalación, ECC activa exactamente un servidor MCP por defecto (chrome-devtools). Para añadir más, copia entradas de mcp-configs/mcp-servers.json al .mcp.json de tu proyecto y actívalas con el comando /mcp de Claude Code. La interfaz /mcp gestiona activar, desactivar y reautenticar.

Si ejecutas tus propias copias de servidores MCP que empaqueta ECC, define:

export ECC_DISABLED_MCPS="github,supabase"

El instalador y los flujos de sync de ECC los omitirán para que no tengas dos servidores peleando por los mismos nombres de herramientas.

Los flujos se encadenan

No ejecutas habilidades de una en una. Un flujo típico para una feature sería:

/ecc:plan "Add OAuth login with Google"
# el agente planner escribe el plano

# la habilidad tdd-workflow se activa según implementas
# fallan los tests, se escribe código, los tests pasan

/code-review
# el agente code-reviewer audita el diff

/security-scan
# AgentShield comprueba el código y la configuración nuevos

Cada paso usa un agente distinto en una ventana de contexto limpia. La sesión principal coordina y el resumen captura la cadena al final para la siguiente sesión.

Everything Claude Code vs. frameworks rivales de configuración

ECC no es la única capa de configuración para Claude Code. Hay otros con tareas similares y distintos trade-offs.

Conviene aclarar la categoría primero. ECC compite con otros frameworks de configuración que se sitúan sobre Claude Code. No compite con los arneses con los que convive (Cursor, Codex, OpenCode, Zed) ni con plataformas de agentes independientes (OpenHands, LangGraph, CrewAI), que son categorías diferentes.

Tres rivales aparecen con más frecuencia.

BMAD-Method es un framework ágil de SDLC con agentes por rol (Analyst, PM, Architect, Scrum Master, Developer, QA). Funciona en Claude Code, Cursor y Windsurf vía npx bmad-method install. Brilla en la fase de planificación inicial: transforma una idea vaga en un PRD, un doc de arquitectura y stories descompuestas antes de escribir código. Su ejecución es más ligera que la de ECC. No hay escáner de seguridad ni catálogo MCP. Menos patrones específicos por lenguaje.

SuperClaude es un framework de configuración ligero basado en Markdown. Unas 30 órdenes con barra, 20 agentes y un par de modos de comportamiento. Se instala con pip install SuperClaude. Es más simple que ECC por diseño: no hay escaneo de seguridad ni runtime de orquestación. Tampoco hay una capa de memoria integrada más allá de la de Claude Code. Si quieres un CLAUDE.md funcional y un conjunto de prompts bien probados, SuperClaude es buena opción.

claude-flow / Ruflo (renombrado desde Claude Flow a inicios de 2026) es un orquestador de enjambres multiagente. Usa la metodología SPARC (specification, pseudocode, architecture, refinement, completion) y ejecuta jerarquías de 60–100+ agentes especializados en paralelo. Tiene memoria persistente vía AgentDB y funciona con Claude, GPT, Gemini y Ollama. La infraestructura es más pesada que la de ECC, y está pensado para trabajo paralelo entre agentes más que para productividad en una sola sesión.

Si quieres explorar más opciones antes de decidir, awesome-claude-code es un directorio curado de recursos de Claude Code (agentes, habilidades, plugins, servidores MCP, configuraciones). Ahí descubre la comunidad la mayor parte de contenidos.

En resumen: elige BMAD si buscas planificación ágil, SuperClaude si quieres una capa ligera, Ruflo si necesitas trabajo multiagente en paralelo y ECC si quieres una plataforma de ingeniería completa con seguridad y memoria persistente integradas.

¿Quién debería usar Everything Claude Code?

ECC no es para todo el mundo. Si usas Claude Code un par de veces por semana para cosas pequeñas, el framework te parecerá mucha carga para poca ganancia. Un único CLAUDE.md de 100 líneas te cubrirá casi todo.

ECC compensa cuando ya has pasado ese punto.

Estos escenarios encajan mejor con ECC que con Claude Code “vanilla”:

• Ingenieros de IA que construyen sistemas con agentes: si diseñas o despliegas flujos con agentes, ECC es una referencia viva. Lee los prompts de agentes, definiciones de habilidades, configuraciones de hooks y toma lo que te sirva.
• Quienes cuidan su productividad como desarrolladores: si inviertes tiempo en tus herramientas, dotfiles, editor y shell, ECC es la misma inversión para Claude Code. Más uso, más valor.
• Equipos que usan Claude Code a diario como infraestructura: si tu equipo lo usa para revisar código, planificar, refactorizar o enviar features cada día, el tiempo ahorrado en consistencia y onboarding se nota. Las nuevas incorporaciones tienen los mismos agentes y flujos.
• Cualquiera que construya flujos complejos con agentes: pipelines multietapa, orquestación de subagentes, encadenado de MCP, contexto persistente, etc. ECC ya ha resuelto muchos de estos problemas y los patrones se pueden reutilizar aunque no instales todo.

Quién no debería elegir ECC:

• Usuarios ocasionales de Claude Code: un par de sesiones semanales de “ayúdame a depurar este script” no necesitan 60+ agentes, 260+ habilidades y una capa de memoria. El setup no compensa.
• Tareas simples y puntuales: scripts rápidos, pequeños fixes, demos, prototipos desechables. Claude Code sin más los maneja bien; añadir ECC suma fricción sin mucho valor.
• Equipos que ya tienen un montaje sólido: si tu CLAUDE.md está afinado y tu flujo es estable, migrar a ECC lleva tiempo. Toma las piezas que te gusten y deja el resto.

Si no lo tienes claro, lo más seguro es leer el repo, copiar dos o tres agentes y habilidades que te interesen y saltarte por ahora la instalación completa.

Ventajas y limitaciones de ECC

A continuación, un repaso a fortalezas y debilidades de ECC. Ambas conviene conocerlas antes de decidir.

Ventajas

• Enorme biblioteca de habilidades: unas 260 habilidades que cubren TDD, auditorías de seguridad, patrones de frameworks, idioms por lenguaje, ingeniería de ML, despliegue y más. Incluso sin instalar nada, el repo es una referencia práctica de cómo escribir buenas definiciones de habilidades.
• Reutilización de flujos: prompts probados para revisión de código, planificación, refactor y tests. El agente revisor de código lo cita mucha gente que ni usa ECC pero se ha llevado el prompt.
• Memoria persistente: resúmenes de sesión y contexto entre sesiones funcionan de serie. La mayoría de configuraciones de Claude Code ni lo abordan.
• Soporte MCP sólido: configuraciones listas para GitHub, Supabase, Vercel, Railway y otros.
• AgentShield: el escáner de seguridad por sí solo justifica instalar ECC aunque no uses nada más. Pocas configs de Claude Code traen algo comparable.
• Open source bajo MIT: nada de paywalls en el core. La app de GitHub alojada y la capa ECC Pro son aparte.
• Multiplataforma: funciona con Claude Code, Cursor, Codex, OpenCode, Zed, Gemini y otros. Si cambias o usas varios, puedes mantener los mismos agentes y habilidades.

Limitaciones

• Curva de aprendizaje: 60+ agentes, 260+ habilidades, tres vías de instalación, cuatro perfiles y un buen puñado de variables de entorno. La primera semana será entender qué está cargado y qué hace cada pieza.
• Complejidad de setup: plugin vs. instalación manual, el tema de que las reglas no se distribuyen por plugin, el problema de hooks duplicados en versiones antiguas de Claude Code, flujos para activar/desactivar MCP, la variable de directorio de datos del agente para multi-arnés. Casi todo está documentado, pero sigue siendo trabajo.
• Mantenimiento continuo: el repo se actualiza a menudo. Los conteos del catálogo cambian entre versiones y los nombres de habilidades también.
• Dependencia del ecosistema de Claude Code: ECC depende de la especificación de plugins, hooks y soporte MCP de Claude Code. Cuando eso cambia, ECC debe adaptarse.
• Sobreingeniería para muchos casos: para la mayoría de equipos, un buen CLAUDE.md de 60–200 líneas cubre el 80% de lo que ofrece ECC. El otro 20% aporta valor, pero solo si lo usas.

El framework es la capa de configuración para Claude Code más completa disponible ahora mismo. Pero "la más completa" no significa "necesaria para todo el mundo".

Conclusión

Si usas Claude Code a diario, ECC merece la pena. Si no, el repo sigue mereciendo la lectura como referencia práctica de cómo construir flujos con agentes que no se deshacen en la práctica.

En todo caso, ECC es una señal clara de que el desarrollo de software se mueve hacia pipelines de agentes programables, no sesiones de chat puntuales. Los frameworks para hacerlo bien aún son nuevos, y ECC es uno de los intentos más completos hasta ahora. No será el último, y ese es el punto.

Si te estás iniciando en la IA generativa y la programación con agentes, apúntate a nuestro curso Generative AI Concepts. Te dará una base sólida para el futuro.