El flujo diario con ECC: /plan, TDD, code review y build-fix en un proyecto real
Al final del artículo tienes el comando, el prompt listo para copiar y un .md para descargar.
El flujo diario de ECC en Claude Code son cuatro pasos: /ecc:plan para que el agente proponga un plan y espere tu confirmación, la skill tdd-workflow para implementar con tests que fallan primero, /ecc:code-review para que un revisor con contexto limpio busque fallos y /build-fix cuando algo no compila. Lo probamos sobre una API pequeña en Node: 19 tests en verde y una revisión con 9 hallazgos.
Esta es la parte 3 de la guía completa de ECC. Si aún no lo tienes, empieza por la parte 2: instalar ECC sin duplicar nada. Aquí verás cada paso con su salida real, cuánto tardó y cuánto costó en tokens, para que sepas qué esperar en tu propio proyecto.
El proyecto de prueba
Partimos de tienda-api, un servidor de node:http de 7 líneas con un único endpoint GET /products y un catálogo en memoria (una camiseta de 15 y una taza de 8). Sin framework, sin dependencias y sin tests: el punto de partida típico de un prototipo.
La tarea: añadir POST /orders, que crea un pedido con productos existentes y calcula el total.
Entorno: Claude Code 2.1.329 con ECC 2.2.3 cargado como plugin (--plugin-dir), modelo Sonnet y modo no interactivo (claude -p) para poder repetir la prueba. Fecha: 20 de noviembre de 2026.
Paso 1: /ecc:plan antes de tocar el código
/ecc:plan "Añadir un endpoint POST /orders que crea un pedido con productos existentes y calcula el total"El comando tiene una regla clara en su definición: reformular los requisitos, buscar patrones en el código, dividir en fases, evaluar riesgos y esperar tu confirmación antes de escribir nada. Y lo cumplió:
Lo que más valor tuvo no fueron las fases, sino dos bloques:
- Riesgos: detectó que el cliente podría mandar su propio precio y decidió calcular el total solo con el catálogo del servidor. También propuso limitar el tamaño del cuerpo (413).
- Decisiones asumidas: fusionar líneas con el mismo
productId, devolver 422 si el producto no existe, separarapp.jsdeserver.jspara poder testear. Te las enseña para que digas si quieres otra cosa.
Tardó 56 segundos. El CLI reportó un coste de 0,37 USD (precio de API, con Sonnet).
Este paso es el que más ahorra: corregir una decisión en el plan cuesta una línea; corregirla en el código, una tarde. Si quieres profundizar en esa forma de trabajar, el capítulo 4 de la guía Claude Code de cero a producción explica cómo planificar antes de programar.
Paso 2: implementar con tdd-workflow
Respondimos al plan con:
yes. Implementa el plan siguiendo la skill tdd-workflow (test que falla primero, luego código). Ejecuta npm test al final y resume qué tests pasaron.La skill tdd-workflow impone el ciclo RED → GREEN → REFACTOR. El agente:
- Refactorizó primero sin cambiar comportamiento:
app.jsconcreateApp()yserver.jsreducido a 2 líneas. - RED: escribió
orders.test.jsconnode:test. Sin la lógica de pedidos, pasaban 2 tests (los de regresión de/productsy del 404) y fallaban 17. - GREEN: implementó
readJson,buildOrdery la ruta. Pasaron los 19. - Midió la cobertura: 98,5 % de líneas y de ramas; solo quedaba sin cubrir el
catchque devuelve 500.
Los tests no son de relleno: cubren que el precio enviado por el cliente se ignora, cantidades 0, negativas, decimales o en texto, items vacío, JSON inválido, cuerpo de más de 100 KB y GET /orders (405).
Tardó 73 segundos y el CLI reportó 0,64 USD.
Un detalle honesto: la skill recomienda hacer commits de control tras RED y tras GREEN, y el agente no los hizo porque no se los pedimos. Si quieres ese historial, dilo en el prompt.
Paso 3: /ecc:code-review con contexto limpio
En una sesión nueva (contexto vacío, sin saber cómo se escribió el código):
/ecc:code-reviewSin argumentos revisa los cambios sin commitear: lista los archivos con git diff, los lee enteros y busca primero problemas de seguridad (críticos) y luego de calidad.
Resultado: ningún problema crítico ni alto, así que no bloquea el commit. Pero encontró cosas que el agente que escribió el código pasó por alto:
req.urlse compara tal cual, así que/products?x=1devuelve 404. Proponenew URL(req.url, 'http://x').pathname.- El 404 responde texto plano cuando todos los demás errores son JSON.
- Tras un 413 no se vacía el resto del cuerpo ni se envía
Connection: close: la conexión puede quedarse abierta. - El array
orderscrece sin límite en un proceso de larga duración. - Faltan tests de redondeo con decimales y de cuerpos
nullo[].
Tardó 25 segundos y costó 0,31 USD. Ojo: en esta sesión no le dimos permiso para ejecutar npm test, y lo avisó al principio ("la revisión es solo de lectura de código"). Si se lo permites, los ejecuta.
Si quieres comparar con otros revisores, en el blog probamos Open Code Review de Alibaba y las skills implement y code-review.
Paso 4: /build-fix cuando no compila
En nuestra API no hubo build roto, así que no lo forzamos. Lo que hace, según su definición:
- Detecta el sistema de build:
npm run buildopnpm buildsi hay script,npx tsc --noEmiten TypeScript,cargo build,go build ./...,mvn compile,./gradlew compileJavaomypy .. - Agrupa los errores por archivo y los arregla uno a uno con el cambio mínimo, volviendo a compilar tras cada arreglo.
- No toca la arquitectura: el agente
build-error-resolvertiene prohibido hacer cambios grandes para que el build pase.
Es el comando que usarás cuando actualices una dependencia y aparezcan 40 errores de tipos.
Cuánto cuesta y cuánto tarda el flujo completo
| Paso | Tiempo | Coste reportado por el CLI |
|---|---|---|
| `/ecc:plan` | 56 s | 0,37 USD |
| Implementación con `tdd-workflow` | 73 s | 0,64 USD |
| `/ecc:code-review` | 25 s | 0,31 USD |
| **Total** | **2 min 34 s** | **1,32 USD** |
Son precios de API con Sonnet en una tarea pequeña. Con suscripción Pro o Max no pagas por token, pero consume tu cuota. En una tarea mayor el plan y la revisión crecen poco; la implementación es la que escala.
Errores frecuentes en el flujo
- Saltarte el plan. Si pides el código directamente, ECC no te obliga a planificar. Ponlo en tu
CLAUDE.md: "usa /ecc:plan antes de cualquier funcionalidad nueva". - Revisar en la misma sesión. El valor de
/ecc:code-reviewes el contexto limpio. Ábrelo en una sesión nueva o con/clearantes. - Pedir TDD sin nombrar la skill. "Hazlo con tests" no es lo mismo que "sigue tdd-workflow": la skill fija el orden RED → GREEN y la cobertura del 80 %.
- Usar
/tddo/verify. En la v2.2 esos atajos se retiraron alegacy-command-shims/. Usa las skillstdd-workflowyverification-loop.
Preguntas frecuentes
¿Funciona con prompts en español? Sí. Le pasamos la tarea en español y el plan salió en español.
¿Puedo usar el flujo sin instalar todo ECC? Sí: con el instalador selectivo puedes copiar solo tdd-workflow, security-review y los comandos que uses (--skills tdd-workflow,security-review).
¿Y si el plan no me gusta? Responde modify: [cambios]. El comando está diseñado para iterar sobre el plan hasta que respondas yes.
Conclusión
El flujo de ECC no hace al agente más listo: lo hace más ordenado. Planificar primero, testear antes de implementar y revisar con otra sesión encontró 9 cosas que mejorar en código que ya pasaba 19 tests. Empieza mañana por /ecc:plan en tu próxima tarea. En la parte 4 vemos los 72 agentes de ECC y cuáles usar según tu stack.
// recurso · úsalo directamente
Flujo plan → TDD → review de ECC listo para pegar
Con ECC instalado como plugin (`ecc@ecc`), pega el prompt que encaje con tu proyecto. Funciona con Claude Code 2.1 o superior.
Licencia del repositorio: MIT
1. Instala
npx ecc-universal@2.2.3 setupgit clone https://github.com/affaan-m/ECC.git && cd ECC && npm install
./install.sh --target claude --skills tdd-workflow,security-review2. Elige tu caso
Vamos a construir esta funcionalidad con el flujo de ECC: <describe la funcionalidad>.
1. Ejecuta /ecc:plan con esa descripción. Enséñame requisitos, fases, riesgos y las decisiones que asumes, y espera mi "yes" o "modify".
2. Cuando lo apruebe, implementa con la skill tdd-workflow: primero los tests que fallan (enséñame cuántos fallan), luego el código mínimo hasta verde y después refactor.
3. Haz un commit tras RED y otro tras GREEN con Conventional Commits.
4. Ejecuta los tests al final y dime la cobertura.
5. No añadas dependencias sin preguntarme.3. Guía de uso
- Pega el prompt y lee el plan con calma: corrige ahí cualquier decisión que no te guste.
- Aprueba con
yes. - Cuando termine, abre una sesión nueva y ejecuta
/ecc:code-review.
Este repositorio ya tiene tests, CI y convenciones en CLAUDE.md. Quiero aplicar el flujo de ECC a este cambio: <describe el cambio o pega la issue>.
1. /ecc:plan con "Pattern Grounding": antes del plan, cita los archivos que usarás como modelo (nombres, manejo de errores, acceso a datos, tests).
2. Marca en el plan qué partes tocan seguridad (auth, pagos, datos personales) y qué tests de autorización harán falta.
3. Espera mi OK. Después implementa con tdd-workflow, commits tras RED y GREEN, sin tocar archivos fuera del plan.
4. Si el build o el typecheck fallan, usa /build-fix con cambios mínimos.
5. Termina con un resumen para el PR: qué cambió, tests añadidos y riesgos pendientes. La revisión la haré con /ecc:code-review en otra sesión.3. Guía de uso
- Lanza el prompt en la rama de la tarea.
- Revisa que los archivos citados como modelo sean los buenos.
- Antes de abrir el PR, ejecuta
/ecc:code-reviewen una sesión limpia y arregla los hallazgos críticos y altos.
Nos ayuda a crecer
codigoagente es gratis y sin muros de pago. Si este artículo te sirvió, cualquiera de estas cosas mantiene el blog en marcha.
- Compártelo con alguien a quien le sirvaWhatsAppLinkedInXFacebook
- Llévate el kit para agenciasVer qué incluyeComprar
- Conoce a nuestro patrocinadorSafe Build Labs
Más sobre Agentes de IA

- Skills para tus agentes
- Claude Code

guía · Guía de psicología para marketing con agentes de IA · #3
- Skills para tus agentes
- Claude Code

guía · Guía de psicología para marketing con agentes de IA · #2
- Skills para tus agentes
- Claude Code