Everything Claude Code (ECC) a prueba: 30 ejecuciones con y sin el plugin
Puse ECC a resolver cinco tareas reales frente a Claude Code sin plugins. Misma calidad en casi todo, 2,8 veces más consumo y ninguna de sus skills usada.

En quince ejecuciones con Everything Claude Code cargado, Claude no invocó ni una sola de sus casi trescientas skills. Y aun así ECC cambió los resultados, para bien en una tarea y para mal en otra, por una pieza que no es ninguna de sus skills.
ECC es uno de los paquetes de configuración para Claude Code más populares: 305.705 estrellas en GitHub el día que lo probé. La versión 2.2.3 declara en su manifiesto 68 agentes, 293 skills, comandos, reglas y una colección de hooks, y se presenta como un sistema para optimizar el rendimiento del agente. Es justo el tipo de promesa que quería comprobar con datos en lugar de fiarme de las estrellas, así que es el primer episodio de una serie que he llamado ¿Útil o fútil?.
El resumen en vídeo dura poco más de un minuto. Si prefieres verlo en YouTube, está en este Short.
Cómo lo he medido
Para que la comparación tuviera sentido necesitaba un proyecto pequeño pero real, tareas fijas y una forma de puntuar que no dependiera de mi impresión. Monté una API en TypeScript para gestionar una mesa de rol, con fichas de personaje, tiradas de dados y un calendario de sesiones, y le planté cinco problemas:
- Un bug: un personaje con Fuerza 9 recibe un modificador de +0 en vez de -1.
- Una feature: tiradas con ventaja y desventaja (
1d20adv,4d6kh3). - Un refactor de
buscarSesiones, una función con complejidad ciclomática 23. - Escribir tests para el almacén de personajes, sin tocar el código.
- Una revisión de seguridad de la API, que tiene un path traversal y un prototype pollution plantados.
Cada tarea tiene tests ocultos que la IA no ve y que solo se copian al proyecto cuando ha terminado. El refactor se comprueba con 300 casos grabados del código original. Los tests de la tarea 4 se evalúan con mutación: les paso 16 versiones del código con un fallo introducido y cuento cuántas detectan.
Las dos configuraciones usaron Claude Sonnet, sin mis plugins ni servidores MCP y sin acceso a la web. ECC se instaló como indica su README, con el plugin y las reglas common y typescript en el proyecto. Cada tarea se repitió tres veces por configuración, porque una sola tirada de un modelo no dice casi nada. En total, 30 ejecuciones lanzadas con claude -p y registradas en JSON.
Lo que pesa ECC antes de empezar
Con un simple «responde OK», Claude Code sin plugins arranca con 18.907 tokens de contexto. Con ECC, 44.439. Son 2,35 veces más antes de haber leído una sola línea del proyecto, porque el agente recibe las descripciones de 315 skills y 74 agentes (las de ECC más las que trae Claude Code) y las reglas, que se cargan siempre.
Ese peso se paga en cada turno de la conversación. No es solo una cuestión de dinero: un contexto lleno de instrucciones que no vienen al caso compite por la atención del modelo con las que sí.
Resultados por tarea
| Tarea | Sin ECC | Con ECC | Consumo medio sin / con |
|---|---|---|---|
| Bug | 0/3 | 2/3 | 0,05 $ / 0,25 $ |
| Feature | 3/3 | 3/3 | 0,14 $ / 0,37 $ |
| Refactor | 3/3 | 3/3 | 0,10 $ / 0,30 $ |
| Tests | 3/3 | 3/3 | 0,17 $ / 0,38 $ |
| Seguridad | 3/3 | 3/3 | 0,30 $ / 0,69 $ |
El consumo es el que calcula Claude Code a precio de API. Yo lo ejecuté con la suscripción, así que lo relevante es la proporción, no la cifra. De media, una tarea con ECC consumió 2,8 veces más y tardó 81 segundos frente a 39.
En tres tareas no hay diferencia de calidad. La feature pasó todos los tests ocultos en las seis ejecuciones. El refactor bajó la complejidad máxima de 23 a entre 6 y 12 en ambas configuraciones, y con ECC el fichero quedó algo más corto (entre 80 y 99 líneas, frente a 100-105). La seguridad también empata, aunque llegar a ese empate me obligó a corregir el banco de pruebas, como cuento más abajo. Las dos tareas interesantes son las otras.
El bug que solo encontró ECC
El fallo plantado estaba en dos sitios. El modificador de característica usaba Math.trunc, que redondea hacia cero, y la tirada de salvación tenía su propia copia del cálculo con el mismo error:
export function abilityModifier(score: number): number {
return Math.trunc((score - 10) / 2);
}
export function savingThrowBonus(character: Character, ability: Ability): number {
const score = character.abilities[ability];
const base = score >= 10 ? Math.floor((score - 10) / 2) : Math.ceil((score - 10) / 2);
// ...
}Sin ECC, Claude corrigió abilityModifier, añadió un test con Fuerza 9 y dio la tarea por terminada en unos 12 segundos. Las tres veces. Con ECC, en dos de las tres ejecuciones encontró también la copia de savingThrowBonus y la sustituyó por una llamada a abilityModifier.
En ninguna de esas ejecuciones se activó una skill. Lo que sí se activó, y mucho, fue un hook. ECC incluye uno llamado Fact-Forcing Gate que bloquea la primera edición de cada fichero hasta que el agente presente ciertos datos. Este es el mensaje que recibió Claude al intentar editar abilities.ts:
PreToolUse:Edit hook error: [Fact-Forcing Gate]
Before editing src/characters/abilities.ts, present these facts:
1. List ALL files that import/require this file (search the tree — Glob/Grep, or find/grep via Bash)
2. List the public functions/classes affected by this change
3. If this file reads/writes data files, show field namesObligar al agente a listar las funciones afectadas por un cambio es exactamente lo que destapa un cálculo duplicado. Mi interpretación es que esta compuerta explica la diferencia en el bug, pero es una inferencia: no he probado el hook aislado del resto de ECC, y en una de las tres ejecuciones el agente pasó por la misma compuerta y aun así se dejó la copia. A lo largo de las quince ejecuciones con ECC, la compuerta bloqueó 49 acciones.
Los tests que sí miraron la seguridad
En la tarea de tests empataron en lo que yo medía: los seis conjuntos de tests detectaron los 16 mutantes. Pero al revisar los resultados encontré algo que mi puntuación inicial había contado como fallo. Algunos tests no pasaban con el código original, y la razón era buena: comprobaban que un PATCH con __proto__ no contaminara Object.prototype o que un id con ../ no permitiera salir del directorio. Habían detectado las vulnerabilidades que yo había dejado para la tarea 5.
Sin ECC, los tests destaparon el prototype pollution en las tres ejecuciones. Con ECC, solo en una. ECC carga reglas de testing y de seguridad en cada sesión, y aun así fue Claude Code sin plugins el que pensó en el caso malicioso. Con tres repeticiones no me atrevo a dar una explicación, pero sí a decir que más instrucciones en el contexto no se tradujeron en tests más atentos.
Dos correcciones al banco de pruebas
Esta prueba me sirvió también para descubrir errores en mi forma de medir, y los dejo escritos porque cambian el marcador.
El primero es el de los tests: los que fallaban con el código original por haber encontrado un bug real ahora cuentan como bugs detectados, y la puntuación de mutantes se calcula solo con los tests que pasan con el original. Sin ese ajuste, la tarea de tests aparecía como 0/3 sin ECC.
El segundo está en la seguridad. Cinco de las seis soluciones, con y sin ECC, añadieron autenticación con token Bearer a las rutas que modifican datos. Es una mejora razonable para una API que se va a exponer a internet, pero mi test oculto hacía el PATCH sin token y recibía un 401. Lo adapté para enviar un token válido y, con eso, las seis soluciones cierran las dos vulnerabilidades sin romper la API.
Hubo además una ejecución, la de seguridad sin ECC en su primera repetición, cuyo registro se cortó sin el evento final. La solución pasa todos los tests, pero su consumo no se conoce y no entra en las medias.
Por qué no se usó ninguna skill
Una skill solo trabaja si el agente decide cargarla, y lo decide a partir de su descripción. Lo expliqué con más detalle en el artículo sobre cómo probar la activación de una skill: una descripción tiene que competir con todo lo demás que hay en el contexto. Con casi trescientas descripciones a la vez, ninguna de estas tareas, bastante corrientes, llevó al agente a cargar ninguna.
Los hooks funcionan de otra manera. No dependen de que el modelo los elija, porque Claude Code los ejecuta en cada evento. Por eso la única parte de ECC con un efecto visible en mis datos fue un hook.
También conviene saber qué hacen esos hooks fuera del proyecto. Al terminar la prueba encontré en mi ~/.claude un bash-commands.log con los comandos que había ejecutado el agente, un cost-tracker.log, una carpeta metrics, otra session-data y un directorio ~/.local/share/ecc-homunculus. Son ficheros locales y no he auditado el resto de lo que hacen esos scripts, pero es justo el tipo de cosa que hay que revisar antes de instalar un plugin de terceros, como conté en qué mirar antes de instalar una skill.
Veredicto: fútil como paquete completo
Instalar ECC entero no mejora a Claude Code en tareas habituales de desarrollo. Con mis cinco tareas, el resultado fue el mismo en tres, mejor en una y peor en otra, a cambio de un consumo 2,8 veces mayor, el doble de tiempo y 25.000 tokens extra de contexto en cada sesión. Para el uso diario, fútil.
Lo que sí me llevo es la idea de la Fact-Forcing Gate. Un hook que pide al agente justificar el alcance de un cambio antes de editar es fácil de escribir y no necesita trescientas skills alrededor. Si tienes un plugin propio, es un buen candidato para añadirlo como hook, como expliqué en cómo organizar un plugin de Claude Code. Y si te interesa algo concreto de ECC, el README permite instalar solo algunas reglas y desactivar los hooks. Elegir dos o tres piezas tiene más sentido que cargarlo todo.
La prueba tiene límites que no quiero esconder. Tres repeticiones por tarea es una muestra pequeña, solo he usado Sonnet y las tareas son cortas, de una sesión. Es posible que ECC aporte más en trabajos largos, con varias sesiones y memoria entre ellas, que es donde ponen el foco algunos de sus componentes. Eso queda para otro episodio. El banco de pruebas ya está montado para repetir esta misma batería con la próxima configuración milagrosa que aparezca.


