Communitygithub.com

recetas-ecc

Mapea un flujo de trabajo descrito al grupo de comandos ECC adecuado, con orden de ejecución y condición de parada, y explora todas las familias de recetas de grupos de comandos.

¿Qué es recetas-ecc?

Este skill proporciona una capa de organización sobre el catálogo plano de comandos slash de ECC, agrupándolos en familias con un orden de ejecución y una condición de parada recomendadas. Es útil para desarrolladores que necesitan saber qué grupo de comandos ejecutar para un flujo de trabajo específico (por ejemplo, construir un MVP, corregir un defecto o refactorizar) sin tener que recordar la lista completa de comandos. Funciona leyendo en vivo el directorio de comandos de ECC, clasificando los comandos por prefijo de nombre en familias (como `multi-*`, `prp-*`, `loop-*`, etc.) y presentando una receta asesora: el orden de ejecución exacto, la condición de parada y enlaces a la documentación detallada. Soporta dos modos: modo catálogo (lista todas las familias y comandos) y modo coincidencia (dada una descripción del flujo, selecciona la mejor familia y genera la receta). Es puramente asesorativo, nunca ejecuta comandos, y está diseñado para usarse con Claude Code, Cursor, Codex u otros agentes que integren el ecosistema ECC.

Compatible con✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/affaan-m/ECC/tree/main/skills/ecc-recipes

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Recetas ECC

Un punto de entrada para "qué grupo de comandos slash de ECC ejecuta mi flujo de trabajo, en qué orden y cuándo debo detenerme". También explora todas las familias de recetas de grupos de comandos.

Llena el vacío entre dos habilidades existentes:

  • ecc-guide — lista comandos y dónde leer la documentación, pero como un catálogo plano.
  • prompt-optimizer — empareja una tarea con componentes, pero genera un solo prompt, no un grupo de múltiples comandos con orden de ejecución y condición de parada.

Esta habilidad añade: agrupación por familias + orden de ejecución + condición de parada.

Cuándo activarla

  • "¿Qué grupo de comandos ejecuto para ?"
  • "¿Cuál es la secuencia de comandos para construir un MVP / corregir un defecto / refactorizar?"
  • "Muéstrame todas las recetas de grupos de comandos de ECC" (modo catálogo)
  • "¿Cuántos pipelines de flujo de trabajo tiene ECC?"
  • El usuario invoca /ecc-recipes con o sin una descripción.

No usar cuando

  • El usuario quiere que la tarea se haga ahora — enruta al comando real, no lo describas.
  • El usuario quiere documentación detallada para UN comando — usa ecc-guide.
  • El usuario quiere reescribir un borrador de prompt — usa prompt-optimizer.

Principio fundamental

Responde desde los archivos actuales, no desde la memoria. El conjunto de comandos cambia; nunca codifiques conteos ni listas de miembros. Lee el directorio commands/ en vivo en cada ejecución y luego clasifica en familias.

Lecturas en vivo

Resuelve el directorio de comandos (el primero que exista) y luego lista los nombres:

for D in \
  "$HOME"/.claude/plugins/marketplaces/ecc/commands \
  "$HOME"/.claude/plugins/cache/ecc/ecc/*/commands \
  ./commands \
  ./.claude/commands \
  "$HOME"/.claude/commands; do
  [ -d "$D" ] && CMD_DIR="$D" && break
done
[ -z "${CMD_DIR:-}" ] && { echo "No se encontró el directorio de comandos de ECC."; return 1; }
find "$CMD_DIR" -maxdepth 1 -name '*.md' -exec basename {} .md \; | sort

Opcionalmente, lee manifests/install-*.json si está presente para un agrupamiento más rico. Usa el conjunto más pequeño de lecturas necesario.

Clasificación por familias (por prefijo)

Agrupa los nombres de los comandos por prefijo inicial; mapea los singleton conocidos manualmente. Las familias se derivan en vivo — la tabla siguiente es la regla de clasificación, no una lista fija.

Prefijo de familiaSignificado de la recetaOrden de ejecución típico
orch-*Research, Plan, TDD, Review, Commit con compuerta por tipo de tareaelige un orch-* según el tipo de tarea; ejecuta sus propias fases internas
multi-*Flujo de trabajo multimodelomulti-plan luego multi-execute luego revisión (o multi-workflow de extremo a extremo)
prp-*Pipeline de PRD a plan a implementación a PRprp-prd luego prp-plan luego prp-implement luego prp-commit luego prp-pr
epic-*Épica grande multiunidad, en paraleloepic-decompose luego epic-claim luego epic-validate luego epic-review luego epic-unblock luego epic-sync luego epic-publish
loop-*Bucle autónomo gestionado y monitorizaciónloop-start <patrón> luego supervisar con loop-status
gan-*Bucle generador y evaluadorgan-build (código) o gan-design (UI); auto-bucles
*-build / *-review / *-testTríada CI por lenguaje<lenguaje>-test (TDD) luego <lenguaje>-build (corregir) luego <lenguaje>-review
hookify-*Gestión de hooks de comportamientohookify luego hookify-list luego hookify-configure
learn / instinct-* / evolve / promote / pruneAprendizaje continuolearn luego instinct-status luego evolve luego promote
singletonsanta-loop, plan, plan-prd, pr, code-review, checkpoint, etc.Independientes o pegamento entre grupos

Cualquier comando que no coincida con una regla de prefijo → listarlo bajo singleton con su descripción de una línea.

Cómo funciona

1. Lee en vivo los nombres de los comandos desde CMD_DIR.
2. Clasifica en familias según el prefijo y un mapa de singleton.
3. Si se proporcionó una descripción del flujo de trabajo -> MODO COINCIDENCIA.
   Si no -> MODO CATÁLOGO.
4. Solo asesorativo: imprime el plan. Nunca ejecutes los comandos coincidentes.

Modo catálogo (sin descripción)

Genera la tabla de familias: cada familia, recuento de miembros, miembros, significado en una línea, orden de ejecución típico. Termina con el recuento total de comandos y un mensaje para describir un flujo de trabajo y obtener una receta personalizada.

Modo coincidencia (descripción proporcionada)

  1. Reformula el flujo de trabajo en una oración.
  2. Elige las 1-2 mejores familias; explica POR QUÉ en una línea cada una.
  3. Bloque de orden de ejecución — secuencia exacta de comandos para la familia seleccionada.
  4. Condición de parada — siempre explícita (máximas ejecuciones, señal de finalización, aprobaciones de revisión o un solo disparo). Para bucles autónomos, advierte sobre el consumo de suscripción y recomienda un límite de seguridad.
  5. Dónde leer — la ruta commands/<nombre>.md más /ecc-guide <nombre>.

Plantilla de salida (modo coincidencia)

Flujo de trabajo: <reformulación en una oración>

Mejor opción: <familia> — <por qué>
(Alternativa: <familia> — <por qué>)

Orden de ejecución:
  /<comando1>   # tarea
  /<comando2>   # tarea
  /<comando3>   # tarea
  DETENER cuando: <condición>
  ADVERTENCIA (solo bucles autónomos): un bucle sin límite consume suscripción/créditos —
  añade un tope de iteraciones máximas o de coste máximo junto con la señal de finalización.

Leer documentación completa:
  commands/<comando1>.md   (o: /ecc-guide <comando1>)

Ejemplos

Catálogo: /ecc-recipes → muestra la tabla de familias y el recuento total.

Coincidencia: /ecc-recipes planificar toda una aplicación por adelantado y luego construir automáticamente con revisión adversaria hasta terminar → Mejor opción: loop-* (autónomo) envolviendo gan-* o santa-loop (adversario). Orden de ejecución: plan-prd luego loop-start rfc-dag --mode safe luego supervisar loop-status; DETENER cuando todas las unidades pasen la revisión N veces consecutivas (añadir un tope de iteraciones máximas para limitar el consumo).

Coincidencia: /ecc-recipes corregir un error en mi servicio Go → Mejor opción: orch-fix-defect (reproducir, corregir, revisar, confirmar). Alternativa: go-test luego go-build luego go-review. DETENER: prueba de regresión verde y aprobación de revisión.

No objetivos

  • No es un ejecutor — solo asesorativo.
  • No es documentación detallada por comando — eso es ecc-guide.
  • No es reescritura de prompts — eso es prompt-optimizer.
  • Nunca codifiques conteos de comandos ni listas de miembros — siempre lee en vivo.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

accessibility

Design, implement, and audit inclusive digital products using WCAG 2.2 Level AA. Use when building or auditing UI that must meet WCAG 2.2 Level AA, or when reviewing a change for keyboard, contrast, or screen-reader support.

affaan-m/content-engine

Create platform-native content systems for X, LinkedIn, TikTok, YouTube, newsletters, and repurposed multi-platform campaigns. Use when the user wants social posts, threads, scripts, content calendars, or one source asset adapted cleanly across platforms.

affaan-m/ECC

Multi-platform content distribution across X, LinkedIn, Threads, and Bluesky. Adapts content per platform using content-engine patterns. Never posts identical content cross-platform. Use when the user wants to distribute content across social platforms.

affaan-m/fal-ai-media

Unified media generation via fal.ai MCP — image, video, and audio. Covers text-to-image (Nano Banana), text/image-to-video (Seedance, Kling, Veo 3), text-to-speech (CSM-1B), and video-to-audio (ThinkSound). Use when the user wants to generate images, videos, or audio with AI.

affaan-m/manim-video

日本語翻訳:このファイルは manim-video 用の日本語翻訳が必要です

affaan-m/remotion-video-creation

Remotion のベストプラクティス - React で動画を作成する。3D、アニメーション、音声、字幕、チャート、トランジションなどをカバーするドメイン固有の29のルール。

affaan-m/video-editing

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

agent-architecture-audit

Full-stack diagnostic for agent and LLM applications. Audits the 12-layer agent stack for wrapper regression, memory pollution, tool discipline failures, hidden repair loops, and rendering corruption. Produces severity-ranked findings with code-first fixes. Essential for developers building agent applications, autonomous loops, or any LLM-powered feature. Use when an agent or LLM feature misbehaves and the failing layer is unknown, or before shipping an agent stack.

agent-eval

Head-to-head comparison of coding agents (Claude Code, Aider, Codex, etc.) on custom tasks with pass rate, cost, time, and consistency metrics. Use when choosing between coding agents, or when a change to an agent setup needs measured pass rate, cost, and time rather than an impression.

agent-harness-construction

Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher completion rates. Use when defining or revising an agent

agentic-engineering

Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing. Use when planning or executing engineering work that agents will carry out end to end.

agentic-os

Build persistent multi-agent operating systems on Claude Code. Covers kernel architecture, specialist agents, slash commands, file-based memory, scheduled automation, and state management without external databases. Use when building a persistent multi-agent system on Claude Code with its own memory, commands, and scheduling.

agent-introspection-debugging

Structured self-debugging workflow for AI agent failures using capture, diagnosis, contained recovery, and introspection reports. Use when an agent run fails and you need a reproducible diagnosis instead of a retry.

agent-payment-x402

Add x402 payment execution to AI agents with per-task budgets, spending controls, and non-custodial wallets. Supports Base through agentwallet-sdk and X Layer through OKX Payments / OKX Agent Payments Protocol. Use when an agent must pay for something itself and needs per-task budgets, spending controls, and a non-custodial wallet.

agent-self-evaluation

Use after completing any non-trivial task. The agent self-rates its output on 5 axes — accuracy, completeness, clarity, actionability, conciseness — with concrete evidence per criterion. Produces a structured 1-5 scorecard with specific improvement suggestions.

agent-sort

Build an evidence-backed ECC install plan for a specific repo by sorting skills, commands, rules, hooks, and extras into DAILY vs LIBRARY buckets using parallel repo-aware review passes. Use when ECC should be trimmed to what a project actually needs instead of loading the full bundle.

ai-first-engineering

Engineering operating model for teams where AI agents generate a large share of implementation output. Use when setting team process, review gates, or ownership rules for a codebase largely written by agents.

ai-regression-testing

Regression testing strategies for AI-assisted development. Sandbox-mode API testing without database dependencies, automated bug-check workflows, and patterns to catch AI blind spots where the same model writes and reviews code. Use when adding regression coverage to AI-assisted code, or when the same model both wrote and reviewed a change.

android-clean-architecture

Clean Architecture patterns for Android and Kotlin Multiplatform projects — module structure, dependency rules, UseCases, Repositories, and data layer patterns. Use when structuring modules, layers, or data flow in an Android or KMP project.

angular-developer

Generates Angular code and provides architectural guidance. Trigger when creating projects, components, or services, or for best practices on reactivity (signals, linkedSignal, resource), forms, dependency injection, routing, SSR, accessibility (ARIA), animations, styling (component styles, Tailwind CSS), testing, or CLI tooling.

Skills relacionados