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

Desde que agentes de código viraram tendência, quantas vezes você já teve que reexplicar seu stack, convenções, preferências e padrões de revisão no começo de cada sessão?

O problema é que toda conversa começa do zero. Ferramentas como o Claude Code sabem escrever código, mas não sabem como o seu time escreve código. O que deveria poupar tempo vira trabalho manual de colar o mesmo contexto do projeto, corrigir o modelo quando ele sai da rota, ajustar instruções e revisar as mesmas sugestões genéricas em toda sessão.

Everything Claude Code (ECC) é um framework open source criado para resolver isso. Apesar do nome, não tem vínculo com a Anthropic. É um sistema de agentes e uma camada de orquestração que roda por cima do Claude Code (não é um modelo, nem um IDE) e transforma um agente genérico em uma plataforma de engenharia especializada que já conhece seus padrões.

Neste artigo, vou explicar o que é o ECC, como as peças se encaixam, como instalar e para quem ele realmente faz sentido.

Mas afinal, o que é o Claude Code? Inscreva-se no nosso curso Claude Code 101 para aprender a usá-lo nos seus fluxos de desenvolvimento do dia a dia.

O que é o Everything Claude Code?

O ECC é um repositório open source que envolve o Claude Code com uma camada operacional pré-configurada para trabalho de engenharia.

Você encontra o projeto em affaan-m/ECC no GitHub. É licenciado sob MIT, mantido por Affaan Mustafa e construído a partir de mais de 10 meses de uso diário do Claude Code em produtos reais. Não é afiliado à Anthropic, apesar do nome.

O repo empacota quatro coisas em uma única instalação:

• Um arcabouço de agentes: um conjunto de subagentes especializados (planner, architect, code reviewer, security reviewer, resolvedor de erros de build e muitos outros) para os quais o Claude Code delega, em vez de tentar fazer tudo em uma única janela de contexto.
• Um ecossistema de skills: algumas centenas de pequenas definições de workflow cobrindo TDD, revisão de segurança, padrões de frameworks (Django, Spring Boot, Next.js e outros), padrões de código por linguagem e tarefas de engenharia de ML.
• Um framework de workflow: hooks que rodam em eventos de ferramenta, regras que sempre se aplicam, configs de servidores MCP e memória de sessão que persiste entre conversas.
• Uma camada de comandos: entradas com barra (slash) mantidas para rodar workflows comuns, além de uma pasta shim retrocompatível para nomes antigos de comandos.

É importante notar que o Claude Code continua sendo o motor. É ele quem lê o código e executa as ferramentas.

O trabalho do ECC é tudo ao redor disso: dizer ao Claude Code qual subagente deve cuidar da tarefa, quais etapas do workflow seguir, quais convenções o seu stack usa e qual contexto levar adiante desde a sessão de ontem.

Na prática, você não precisa mais configurar o Claude Code do zero em cada projeto. Você instala o ECC uma vez, copia os pacotes de regras do seu stack e passa a ter uma plataforma de engenharia especializada que já sabe como proceder daí em diante.

Por que o Everything Claude Code ficou tão popular

O crescimento começou com um thread no X.

No início de 2026, Mustafa publicou The Shorthand Guide to Everything Claude Code. Em poucos dias, passou de 10 mil favoritos. Depois ele abriu o repo, e o ECC já ultrapassou 200 mil estrelas e 34+ forks.

Eis por que isso aconteceu:

• Coding agent saiu do experimento para o uso diário: À medida que mais devs passaram a usar o Claude Code, as limitações do sistema padrão ficaram evidentes. O que os devs precisavam era de uma camada de configuração pronta que eliminasse o início frio de contexto, a inconsistência nas saídas de code review e afins.
• Escrever bons prompts de agente é mais difícil do que parece: Um workflow de TDD sólido ou um prompt de code reviewer com filtro por confiança exige iteração. Muitos times não querem construir e manter isso do zero conforme os modelos evoluem, então reutilizar a versão testada de outra pessoa é o caminho mais simples.
• As contribuições se acumularam: Mais de 270 contribuidores adicionaram pacotes de regras de linguagem (Java, Kotlin, Rust, Perl, PHP), suporte a frameworks (Quarkus, Laravel), traduções, integrações com IDEs além do Claude Code (Cursor, OpenCode, Zed) e novas skills.
• O ECC traz especialização sem fine-tuning: Fazer fine-tuning de modelo com convenções do time não é prático para a maioria. Um conjunto estruturado de skills e agentes em tempo de execução chega perto do mesmo efeito, e o ECC é uma das tentativas mais completas de empacotar isso.

Começou como um thread no X e virou bola de neve.

Como o Everything Claude Code funciona

O ECC é um sistema em camadas.

Existem cinco componentes entre você e seu codebase. O Claude Code é o runtime. Skills, agentes, MCP e uma camada de memória o envolvem. Cada peça faz um trabalho e repassa tarefas entre si durante a sessão.

Claude Code

O Claude Code é a interface de modelo subjacente.

É o CLI oficial da Anthropic para rodar o Claude como agente de código. Ele lê arquivos, escreve diffs, executa comandos no shell, chama ferramentas e mantém a conversa. O ECC não substitui nada disso. Tudo o que o ECC adiciona é carregado no Claude Code no início da sessão e roda pelo sistema existente de plugins, hooks e comandos.

Skills

Skills são instruções de workflow reutilizáveis, armazenadas como arquivos Markdown.

Cada skill é uma pastinha com um SKILL.md que diz ao Claude Code como lidar com um tipo específico de tarefa. A skill define a descrição, as etapas, a saída esperada e as restrições. O ECC tem cerca de 260 skills que cobrem padrões de linguagem, workflows de testes, convenções de frameworks, engenharia de ML e tarefas operacionais.

O ponto é: você não roda skills manualmente. O Claude Code as escolhe com base no que você está fazendo, ou você as referencia no prompt.

Agentes

Agentes são subagentes especializados para os quais o Claude Code delega.

Cada um é definido em Markdown com nome, descrição, lista de ferramentas permitidas e um system prompt que delimita seu comportamento. O agente code-reviewer só lê arquivos e reporta achados. O planner escreve blueprints de implementação antes de tocar no código. Deu para entender.

A razão dessa divisão é isolar contexto. Cada subagente recebe uma janela de contexto limpa para sua tarefa, então a sessão principal não fica lotada. O agente principal coordena e os subagentes executam.

Integrações MCP

MCP (Model Context Protocol) é como o Claude Code conversa com ferramentas e fontes de dados externas.

O ECC traz configs para conectar GitHub, Supabase, Vercel, Railway e outros via servidores MCP. Cada servidor expõe ferramentas que o Claude Code pode chamar no meio da sessão. O ECC apenas empacota configs funcionais e regras de segurança para eles.

Por padrão, o ECC habilita um conector (chrome-devtools). O restante é opt-in, o que evita colisão de nomes de ferramentas e mantém a superfície de ataque menor.

Camada de memória

A camada de memória torna o ECC com estado entre sessões.

Hooks rodam no evento Stop de cada conversa e escrevem um resumo da sessão em ~/.claude/sessions/. A próxima sessão carrega o contexto relevante no início por meio de um hook SessionStart. Skills que o modelo “aprende” com seus padrões são extraídas para o sistema Continuous Learning v2, onde viram instintos com pontuações de confiança e podem ser reutilizadas depois.

Apelidos de sessão, skills aprendidas e métricas ficam sob uma raiz única de dados do agente (padrão ~/.claude, configurável por harness se você rodar o ECC tanto no Claude Code quanto no Cursor).

Como as peças trabalham juntas

Uma sessão típica é assim:

1. Início da sessão: um hook carrega o contexto da sessão anterior, mais skills e regras relevantes do projeto atual.
2. Você pede algo: por exemplo, “adicionar login com OAuth”.
3. O agente planner roda primeiro: escreve um blueprint — ainda sem código.
4. Entra a skill de TDD: o Claude Code segue o fluxo de teste falhando, implementação mínima e refatoração.
5. Ferramentas MCP são chamadas: talvez o MCP do GitHub busque PRs relacionados, ou o MCP do Supabase cheque o schema.
6. O agente code-reviewer roda ao final: audita o diff na própria janela de contexto e reporta.
7. A sessão termina: um hook Stop escreve um resumo, extrai novos padrões como instintos e os guarda para a próxima vez.

O modelo continua sendo o Claude Code. O ECC só orquestra qual skill, qual agente e qual ferramenta usar em cada etapa.

Skills no Everything Claude Code

Skills são a principal forma de o ECC dizer ao Claude Code o que fazer.

Uma skill é uma pasta com um arquivo SKILL.md. O Markdown define a descrição, as etapas, as restrições, a saída esperada e os contextos de aplicação. É só um arquivo texto que o modelo lê em tempo de execução.

E isso é de propósito. O ECC não está “re-treinando” nada; ele carrega instruções que o Claude lê e segue na hora.

As skills ficam no diretório skills/ na raiz do repo. Após a instalação, elas são copiadas para ~/.claude/skills/. O Claude Code carrega essas pastas diretamente.

Cada pasta de skill tem a mesma estrutura básica:

• SKILL.md - a definição do workflow
• Arquivos de apoio opcionais (templates, scripts, exemplos)
• Um metadata.yaml opcional para tags e descoberta

As skills influenciam o comportamento dos agentes de duas formas. Primeiro, o Claude Code as lê no início da sessão e as mantém disponíveis para referência. Depois, o modelo seleciona a skill relevante conforme seu pedido. Se você disser “escreva primeiro um teste que falha”, a skill de TDD ativa. Se disser “revise isso para SQL injection”, ativa a skill de revisão de segurança.

O ECC vem com cerca de 260 skills. Aqui vão algumas para mostrar a variedade:

• frontend-patterns: convenções de React e Next.js. Estrutura de componentes, uso de hooks, decisão entre componentes de servidor e cliente, padrões de estado.

• django-patterns, django-tdd, django-security, django-verification: uma stack Django completa dividida em quatro skills. Uma para arquitetura, outra para o ciclo de testes, outra para auditorias estilo OWASP e outra para o loop de verificação antes de enviar.

• architect (em par com o agente architect): revisões de design de sistemas. A skill define o que uma revisão de arquitetura cobre, que artefatos produz e quais trade-offs destacar.

• tdd-workflow: o ciclo vermelho-verde-refatora. Escreva o teste que falha, o mínimo para passar, refatore e verifique cobertura. A skill impõe a ordem.

• security-review: checklist do OWASP Top 10, detecção de credenciais hardcoded, revisão de validação de entradas e checagem de vulnerabilidades em dependências. A skill define o que escanear e o que sinalizar.

Agentes no Everything Claude Code

Agentes são “personas” especializadas com suas próprias janelas de contexto.

Cada um é um arquivo Markdown na pasta agents/ com nome, descrição, allowlist de ferramentas e um system prompt. O system prompt define o trabalho do agente. O allowlist controla o que ele pode fazer (ler arquivos, rodar bash, chamar servidores MCP, escrever código). O Claude Code delega tarefas automaticamente para um agente.

O ECC tem 66 agentes, agrupados em algumas categorias.

Agentes de planejamento rodam antes de qualquer linha de código ser escrita.

O agente planner decompõe um pedido de feature em um blueprint de implementação: arquivos a alterar, interfaces a definir, testes a escrever, casos de borda a tratar. O architect sobe o nível: design de sistema, modelo de dados, limites de serviços. Eles só leem código e escrevem planos.

Agentes de codificação fazem a implementação.

O tdd-guide impõe o ciclo test-first. Resolutores específicos por linguagem, como go-build-resolver, pytorch-build-resolver e kotlin-build-resolver corrigem erros de build em seus ecossistemas. O refactor-cleaner remove código não utilizado.

Agentes de arquitetura revisam decisões estruturais.

O architect cobre design; o database-reviewer cobre padrões de query e escolhas de schema; e o mle-reviewer audita pipelines de ML em produção (data contracts, cobertura de avaliação, serving, monitoramento).

Agentes de QA verificam o que foi construído.

O code-reviewer audita diffs quanto a qualidade e segurança com um limiar de confiança. O security-reviewer faz uma passada estilo OWASP. O e2e-runner lida com testes end-to-end em Playwright. Revisores por linguagem (typescript-reviewer, python-reviewer, go-reviewer, rust-reviewer e outros) fazem checagens específicas de linguagem.

O motivo de dividir tudo isso em agentes separados é isolar contexto.

Quando o code-reviewer roda, ele recebe uma janela de contexto fresca com apenas o diff e a skill de revisão carregados. Ele não vê as notas de planejamento nem o histórico da conversa. Ele só revisa. Esse foco produz uma saída melhor do que pedir a um agente geral para planejar, codar, testar e revisar no mesmo contexto — que é onde a maioria dos setups ad hoc de Claude Code acaba caindo.

Gestão de contexto e memória no ECC

O ECC não esquece tudo entre sessões como o Claude Code faz.

A memória no ECC é um sistema de hooks que escrevem arquivos nos momentos certos e os recarregam na hora certa. São apenas arquivos Markdown e JSON no disco.

Três coisas persistem:

1. Resumos de sessão são escritos quando a sessão termina: um hook Stop roda após a última mensagem, pega a transcrição completa e escreve um resumo em ~/.claude/sessions/. O resumo cobre o que foi trabalhado, o que foi decidido e o que ficou em aberto. A próxima sessão o lê durante um hook SessionStart para o Claude saber de onde partir.
2. Instintos são padrões extraídos das suas sessões: o sistema Continuous Learning v2 observa o que você faz e o que funciona, depois escreve instintos individuais com uma pontuação de confiança, uma ação, evidências e exemplos. Rode /instinct-status para ver o que foi aprendido. Rode /evolve para agrupar instintos relacionados em uma nova skill.
3. Arquivos de log acompanham a camada operacional: execuções de hooks, rodadas de skills, chamadas MCP, custos, erros. Vivem em ~/.claude/metrics/ e ~/.claude/session-data/. Úteis para debug e para o dashboard GUI que vem no repo.

Se você acha que isso não é grande coisa, aqui vão alguns motivos que provam o contrário:

• Projetos de longa duração: um refactor de seis meses não reinicia toda segunda. As decisões, trade-offs e problemas conhecidos da semana passada estão no resumo que carrega no início da sessão.
• Sem repetição de explicações: você não precisa recolar seu stack, suas convenções ou “lembre que decidimos usar Postgres, não Oracle” toda vez.
• Contornando limites de janela de contexto: mesmo com janela de um milhão de tokens, não cabe a história de seis meses de projeto. Resumos comprimem o que importa. O histórico completo fica no disco; o modelo recebe a parte relevante.

Você pode ajustar o contexto carregado com variáveis de ambiente. ECC_SESSION_START_MAX_CHARS limita quantos caracteres de resumo carregam no início (padrão 8.000). ECC_SESSION_START_CONTEXT=off desativa para setups de baixo contexto. ECC_SESSION_RETENTION_DAYS controla por quanto tempo as sessões permanecem antes da limpeza.

Se você roda o ECC no Claude Code e no Cursor na mesma máquina, defina ECC_AGENT_DATA_HOME para manter as memórias separadas. Caso contrário, elas sobrescrevem os arquivos de sessão uma da outra.

Suporte a MCP no Everything Claude Code

MCP é como o Claude Code chama qualquer coisa que não seja arquivo ou comando de shell.

O Model Context Protocol é o padrão da Anthropic para conectar modelos de linguagem a ferramentas externas. Um servidor MCP roda como processo separado e expõe um conjunto tipado de operações: “ler esta página do Notion” ou “abrir um PR no GitHub”. O Claude Code chama essas operações como se fossem funções.

O ECC traz configs de MCP em mcp-configs/mcp-servers.json para serviços comuns: GitHub, Supabase, Vercel, Railway, Linear e outros. Cada entrada inclui o comando para iniciar o servidor, variáveis de ambiente necessárias e as regras de segurança aplicadas pelo ECC.

Vale saber que o ECC não habilita isso automaticamente.

A política de conectores MCP de junho de 2026 reduziu os servidores habilitados por padrão para um (chrome-devtools). O resto é opt-in. Você pode copiar a entrada para o .mcp.json do seu projeto ou habilitar pelo comando /mcp do Claude Code. O motivo é prático (nomes longos de ferramentas MCP quebram alguns gateways) e também de segurança (cada servidor MCP é uma potencial superfície de ataque).

Na prática, o suporte funciona assim:

• Integrações externas: adicione a entrada do GitHub ao .mcp.json, forneça um token e o Claude Code poderá ler issues, abrir PRs e checar o status do CI sem você precisar copiar e colar.
• Chamada de ferramentas: skills e agentes referenciam ferramentas MCP pelo nome. Por exemplo, uma skill de deploy pode chamar o MCP da Vercel, e um agente de revisão de banco pode chamar o MCP do Supabase.
• Automação de projeto: você pode combinar servidores MCP com hooks para ter automações persistentes entre sessões. Um hook de PR aberto pode iniciar um agente de revisão que usa o MCP do GitHub para buscar o diff e o MCP do Linear para atualizar o ticket.

Se você já roda versões próprias de MCPs que o ECC inclui, defina ECC_DISABLED_MCPS como uma lista separada por vírgulas. O ECC vai pular esses durante instalação e sync, evitando duplicatas brigando pelo mesmo nome de servidor.

AgentShield e recursos de segurança

Segurança é um dos diferenciais do ECC.

AgentShield é um auditor de segurança independente que vem com o ECC. Ele escaneia configurações do Claude Code em busca de vulnerabilidades, más configurações, erros e riscos de injection. Roda como um pacote npm separado (ecc-agentshield), mas está conectado ao ECC pela skill /security-scan, para você rodar de dentro de uma sessão do Claude Code.

A varredura cobre cinco categorias:

• Detecção de segredos: 14 padrões para credenciais hardcoded, chaves de API, tokens.
• Auditoria de permissões: o que cada agente e skill pode acessar (ferramentas e paths) e se as concessões estão amplas demais.
• Análise de hook injection: se hooks podem ser explorados para rodar comandos arbitrários.
• Perfil de risco de servidores MCP: o que cada servidor MCP conectado pode ler, escrever ou chamar e onde isso gera exposição.
• Revisão de configs de agentes: vetores de prompt injection, listas de ferramentas permissivas demais, restrições ausentes.

Você pode rodar com este comando, sem instalar nada:

npx ecc-agentshield scan

A saída é uma nota (de A a F) mais a lista de achados, ordenada por severidade. Achados críticos saem com código 2.

Algumas flags úteis:

• -fix aplica correções automáticas para problemas seguros (remover segredos expostos, apertar permissões amplas demais…)
• -opus roda o scan por três agentes Claude Opus 4.X em um pipeline red team / blue team / auditor. O atacante tenta encontrar cadeias de exploração. O defensor avalia as proteções. O auditor sintetiza tudo em um relatório de risco priorizado.
• -stream transmite a análise ao vivo, útil em configs mais lentas.

A abordagem com pipeline Opus é o que diferencia o AgentShield de um linter genérico. Agentes adversariais tentam encadear componentes aparentemente OK em algo explorável — a origem da maioria dos ataques reais a agentes.

O AgentShield reporta 102 regras de análise estática e 1.282 testes internos com 98% de cobertura, segundo o repo. Vale conferir os números na versão mais recente, mas dá para ver que não é um script de 50 linhas.

Os formatos de saída incluem terminal (com cores), JSON (para CI), Markdown e HTML. Há também uma GitHub Action e um GitHub App separado (ECC Tools) que roda o AgentShield em PRs.

Para a maioria dos times que usam Claude Code em produção, o AgentShield é o motivo mais concreto para instalar o ECC — mesmo que você não use o resto do framework.

Instalando o Everything Claude Code

O ECC tem dois caminhos de instalação.

O erro mais comum é empilhar a instalação via plugin em cima da instalação manual. Ambos copiam os mesmos arquivos para os mesmos lugares e você acaba com duplicatas. Então, antes de tudo: escolha só um caminho.

Antes de instalar, confirme o Claude Code na versão v2.1.0 ou superior:

claude --version

Versão do Claude

Instalação via gerenciador de plugins

Este é o caminho recomendado para a maioria dos usuários.

De dentro do Claude Code, rode:

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

Instalação do plugin

O primeiro comando registra o repo do ECC como marketplace. O segundo instala o plugin.

Um porém: o sistema de plugins não distribui regras. Regras são as diretrizes sempre ativas (estilo de código, workflow de git, padrões de testes, padrões por linguagem) e a especificação de plugins do Claude Code não as inclui. Você copia isso manualmente após instalar o 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/

Copie rules/common mais um pacote de linguagem que você realmente use. No exemplo acima, copiei as regras de Python. Não copie tudo: mais regras significam mais contexto carregado em cada sessão — e a maior parte não vai se aplicar ao seu projeto.

Instalação via arquivos de configuração

Use esta abordagem se você quer controle total ou se a instalação via plugin não funcionar no seu setup.

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

No Windows:

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

Isso copia agentes, skills, comandos, hooks e regras para o diretório ~/.claude/. Sem camada de plugin. Tudo vive como arquivos no disco que o Claude Code lê ao iniciar a sessão.

Algumas opções de perfil que valem conhecer:

• -profile minimal: apenas regras, agentes, comandos e skills centrais, sem hooks.

• -profile core: o conjunto padrão de trabalho. Inclui hooks.

• -profile full: tudo que está no repo.

Você também pode instalar componentes específicos com --modules ou --with:

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

Se não tiver certeza do que instalar, pergunte ao advisor incluído:

npx ecc consult "security reviews" --target claude

Ele retorna os componentes correspondentes e os comandos exatos de instalação.

Verificando a instalação

Veja o que foi instalado:

/plugin list ecc@ecc

Verificação da instalação do plugin

Isso mostra os agentes, comandos e skills disponíveis pelo plugin. Para instalações manuais, use o wrapper de lifecycle:

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

doctor checa arquivos ausentes, hooks quebrados e conflitos de versão. Se apontar algo, rode:

node scripts/ecc.js repair

Para confirmar que o Claude Code reconheceu o novo plugin, abra uma sessão e tente um comando com barra:

/ecc:plan "Add user authentication"

Saída do plano do ECC

Para instalação via plugin, o prefixo com namespace /ecc: é obrigatório. Para instalação manual, a forma curta (/plan) funciona.

Se algo parecer duplicado ou quebrado, não reinstale por cima. Rode node scripts/uninstall.js --dry-run para ver o que seria removido e, em seguida, node scripts/uninstall.js para limpar. O ECC só remove arquivos que ele mesmo instalou; configs não relacionadas permanecem intactas.

Trabalhando com skills, comandos e workflows

A maior parte do que você faz no ECC passa por skills, não por comandos.

Isso porque a pasta commands/ é mantida por compatibilidade retroativa, mas o desenvolvimento de novos workflows acontece primeiro em skills/.

Aqui estão alguns padrões de uso que cobrem a maior parte do seu dia a dia.

A ativação de skills é majoritariamente implícita

Você normalmente não chama uma skill pelo nome. Você descreve o que quer e o Claude Code escolhe a skill que se encaixa. Se você disser “escreva primeiro um teste que falha”, a skill tdd-workflow será ativada. Os nomes das skills aparecem na resposta para você ver o que foi carregado.

Quando quiser ser explícito, referencie a skill no prompt: “Use a skill django-tdd para adicionar o novo endpoint.” Ou rode um comando que a encapsule:

/code-review
/security-scan

/ecc:plan "Add OAuth login"

O prefixo /ecc: é obrigatório em instalações via plugin. Em instalações manuais, use a forma curta (/plan, /code-review).

Saída da fase de planejamento do ECC

O direcionamento de arquivos faz parte do workflow

A maioria dos agentes e skills trabalha com um escopo específico: um arquivo, um diretório, um diff, um PR. Você define o escopo mencionando o arquivo no prompt, abrindo-o no editor antes de invocar, ou apontando o agente para um caminho:

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

O agente capta o escopo, carrega só os arquivos necessários e roda na sua própria janela de contexto.

A integração com shell usa a ferramenta bash do Claude Code

Skills podem chamar o shell para o que precisar de execução real — rodar testes, build, linters ou CLIs. A skill de TDD roda pytest ou go test. O agente de correção de build roda o build de verdade para ver erros reais. A skill de segurança roda npx ecc-agentshield scan e interpreta a saída.

A skill define quais comandos de shell rodam e quando. Hooks também podem rodar comandos em eventos de ferramenta (rodar typecheck após cada edição, avisar sobre console.log antes de salvar).

A gestão de MCP é majoritariamente opt-in

Após a instalação, o ECC habilita exatamente um servidor MCP por padrão (chrome-devtools). Para adicionar mais, copie entradas de mcp-configs/mcp-servers.json para o .mcp.json do seu projeto e habilite pelo comando /mcp do Claude Code. A interface /mcp gerencia habilitar, desabilitar e reautenticar.

Se você roda suas próprias cópias de servidores MCP que o ECC inclui, defina:

export ECC_DISABLED_MCPS="github,supabase"

O instalador e os fluxos de sync do ECC vão pular esses, evitando dois servidores iguais brigando pelos mesmos nomes de ferramentas.

Workflows se encadeiam

Você não roda skills isoladamente. Um fluxo típico de feature é:

/ecc:plan "Add OAuth login with Google"
# o agente planner escreve um blueprint

# a skill tdd-workflow ativa enquanto você implementa
# testes falham, código é escrito, testes passam

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

/security-scan
# o AgentShield checa o novo código e a config

Cada etapa usa um agente diferente em uma janela de contexto nova. A sessão principal coordena, e o resumo da sessão captura a cadeia no final para disponibilizar na próxima.

Everything Claude Code vs. frameworks rivais de configuração

O ECC não é a única camada de configuração para o Claude Code. Há outras opções com tarefas semelhantes e trade-offs diferentes.

Vale alinhar a categoria primeiro. O ECC compete com outros frameworks de configuração que rodam por cima do Claude Code. Ele não compete com os harnesses ao lado dele (Cursor, Codex, OpenCode, Zed) nem com plataformas de agentes independentes (OpenHands, LangGraph, CrewAI), que são categorias diferentes.

Três rivais aparecem com mais frequência.

BMAD-Method é um framework ágil de SDLC com agentes por papel especializado (Analyst, PM, Architect, Scrum Master, Developer, QA). Roda em Claude Code, Cursor e Windsurf via npx bmad-method install. Brilha na fase inicial de planejamento, transformando uma ideia vaga em PRD, documento de arquitetura e histórias decompostas antes de qualquer código. A execução é mais leve que a do ECC. Não há scanner de segurança nem catálogo de MCP. Há menos padrões por linguagem.

SuperClaude é um framework leve baseado em Markdown. Cerca de 30 comandos com barra, 20 agentes e alguns modos de comportamento. Instala com pip install SuperClaude. É mais simples que o ECC por design: sem varredura de segurança e sem runtime de orquestração. Também não há camada de memória além do que o Claude Code oferece. Se você quer um CLAUDE.md funcional com um conjunto de prompts bem testados, o SuperClaude é uma boa pedida.

claude-flow / Ruflo (renomeado de Claude Flow no início de 2026) é um orquestrador de enxames multiagente. Usa a metodologia SPARC (specification, pseudocode, architecture, refinement, completion) e roda hierarquias lideradas por “queen” de 60–100+ agentes especializados em paralelo. Tem memória persistente via AgentDB e funciona com Claude, GPT, Gemini e Ollama. A infraestrutura é mais pesada que a do ECC e foi feita para trabalho paralelo de agentes, não produtividade em uma única sessão.

Se quiser explorar mais opções antes de decidir, o awesome-claude-code é um diretório curado de recursos do Claude Code (agentes, skills, plugins, servidores MCP, configs). É onde acontece boa parte da descoberta pela comunidade.

Resumindo: escolha BMAD se você quer planejamento no estilo ágil; SuperClaude se quiser uma camada leve de configuração; Ruflo se precisa de trabalho multiagente em paralelo; e ECC se busca uma plataforma de engenharia completa, com segurança e memória persistente embutidas.

Quem deve usar o Everything Claude Code?

O ECC não é para todo mundo. Se você usa o Claude Code só algumas vezes por semana para tarefas pequenas, o framework vai parecer pesado para pouco retorno. Um único CLAUDE.md de 100 linhas cobre a maioria do que você precisa.

O ECC compensa quando você já passou desse ponto.

Cenários em que ele é melhor que o Claude Code puro:

• Engenheiros de IA construindo sistemas agentic: se você está desenhando ou implantando workflows de agentes, o ECC é uma referência prática. Leia os prompts de agentes, as definições de skills, as configs de hooks e aproveite o que funcionar.
• Quem curte produtividade de dev: se você investe no seu tooling, dotfiles, setup de editor e shell, o ECC é o mesmo tipo de investimento para o Claude Code. Você tira mais proveito quanto mais usa.
• Times que usam o Claude Code como infraestrutura diária: se seu time usa o Claude Code para code review, planejamento, refatoração ou entrega de features todos os dias, o ganho de consistência e onboarding soma. Novos integrantes recebem os mesmos agentes e workflows.
• Quem constrói workflows complexos de agentes: pipelines multietapas, orquestração de subagentes, encadeamento de MCP, contexto persistente — para citar alguns. O ECC já resolveu a maioria desses problemas, e os padrões são reutilizáveis mesmo sem instalar tudo.

Quem não deve usar o ECC:

• Usuários casuais do Claude Code: algumas sessões por semana de “me ajuda a debugar esse script” não pedem 60+ agentes, 260+ skills e uma camada de memória. O esforço de setup não compensa.
• Tarefas simples e pontuais: scripts rápidos, pequenos fixes, demos, protótipos descartáveis. O Claude Code puro dá conta; adicionar ECC só cria atrito sem muito valor.
• Times que já têm um setup funcionando: se o seu CLAUDE.md está redondo e o workflow é estável, migrar para o ECC exige tempo. Pegue as partes que você gosta e deixe o resto.

Se estiver em dúvida, o caminho seguro é ler o repo, copiar dois ou três agentes e skills interessantes e pular a instalação completa por enquanto.

Vantagens e limitações do ECC

Agora, um panorama dos pontos fortes e fracos do ECC. Ambos importam antes de decidir.

Vantagens

• Biblioteca enorme de skills: cerca de 260 skills cobrindo TDD, auditorias de segurança, padrões de frameworks, idiomatismos de linguagem, engenharia de ML, deploy e mais. Mesmo que você não instale nada, o repo é uma referência prática de como escrever boas definições de skill.
• Reuso de workflows: você ganha prompts testados para code review, planejamento, refatoração e testes. O agente de code review, em especial, é citado por gente que nem usa o ECC, mas pegou o prompt emprestado.
• Memória persistente: resumos de sessão e contexto entre sessões funcionam out of the box. A maioria das configs do Claude Code nem toca em memória.
• Bom suporte a MCP: configs prontas para GitHub, Supabase, Vercel, Railway e outros.
• AgentShield: o scanner de segurança por si só já justifica instalar o ECC, mesmo que você não use mais nada. Pouquíssimas configs de Claude Code têm algo parecido.
• Open source sob MIT: sem paywall no core. O GitHub App hospedado e o ECC Pro são à parte.
• Multiplataforma: funciona com Claude Code, Cursor, Codex, OpenCode, Zed, Gemini e outros. Se você troca ou usa vários, ainda pode aproveitar os mesmos agentes e skills.

Limitações

• Curva de aprendizado: 60+ agentes, 260+ skills, três caminhos de instalação, quatro tipos de perfil e um monte de variáveis de ambiente. A primeira semana é para entender o que carrega e o que cada peça faz.
• Complexidade de setup: plugin vs. manual, a questão de regras não distribuídas via plugin, problema de hooks duplicados em versões antigas do Claude Code, fluxos de habilitar/desabilitar MCP, variável de diretório de dados do agente para uso multi-harness. Está documentado, mas dá trabalho.
• Sobrecarga de manutenção: o repo atualiza com frequência. Contagens mudam entre releases e nomes de skills podem mudar.
• Dependência do ecossistema do Claude Code: o ECC depende da spec de plugins, do sistema de hooks e do suporte a MCP do Claude Code. Quando o Claude Code muda isso, o ECC precisa acompanhar.
• Overengineering para muitos casos: para a maioria dos times, um bom CLAUDE.md de 60–200 linhas cobre 80% do ECC. Os outros 20% valem a pena — mas só se você for usar.

O framework é hoje a camada de configuração mais completa para o Claude Code. Mas “mais completa” não significa “necessária para todo mundo”.

Conclusão

Se você usa o Claude Code diariamente, o ECC merece sua atenção. Se não usa, o repo ainda vale a leitura como referência prática de como construir workflows de agentes que funcionam no mundo real.

De todo modo, o ECC é um sinal claro de que o desenvolvimento de software está migrando para pipelines programáveis de agentes, e não sessões de chat pontuais. Os frameworks para fazer isso bem ainda são novos, e o ECC é uma das tentativas mais completas até agora. Não será a última — e essa é a ideia.

Se você está começando em IA generativa e coding agentic, inscreva-se no nosso curso Generative AI Concepts. Ele vai te dar uma base sólida para o futuro.