Most developers use Claude Code, Codex, or Cursor at maybe 30% capacity β€” basic chat-based code generation with default settings. Everything Claude Code (ECC) is an open-source configuration system that treats these tools not as chatbots, but as full AI agent orchestration platforms. It has 84,000+ GitHub stars, 108+ skills, 25+ specialized agents, and a continuous learning system that gets smarter across sessions.

If your team is investing in AI-assisted development and hasn’t evaluated ECC’s architecture, you’re leaving significant capability on the table.

From Hackathon Win to 84k Stars

Everything Claude Code started with a bet. In September 2025, Affaan Mustafa and teammate @DRodriguezFX entered the Anthropic Γ— Forum Ventures hackathon in New York City. Among 100+ competing teams, they built zenith.chat β€” a complete AI product β€” in eight hours using nothing but Claude Code. They won first place and a $15,000 Anthropic API credit prize.

The edge wasn’t a novel algorithm. It was 10 months of Claude Code configuration refinement that Affaan had built up through daily production use. After the win, he open-sourced the entire system.

Affaan’s background matters here. He’s a co-founder of ItΓ΄ (a prediction market aggregator), a core contributor to elizaOS (the most widely used AI agent framework in Web3, 17k+ stars), and previously built autonomous trading agents that hit 70k concurrent viewers and $38M peak FDV. The guy knows agent systems.

The repo launched on January 17, 2026 with 9 agents, 14 commands, and 11 skills. By late January it had 50,000 stars. By March 2026: 84,000+ stars, 30+ contributors, translations in five languages, and 997 passing tests. It’s one of the fastest-growing developer tool repositories in GitHub history.

The Four-Layer Architecture

ECC isn’t a grab bag of tips. It’s a structured system with four distinct layers, each building on the one below it. Understanding this architecture is the key to understanding why Everything Claude Code works.

Layer 1: User Interaction β€” Commands and Rules

57+ slash commands serve as entry points into structured workflows:

  • Core workflow: /plan, /tdd, /e2e for task planning, test-driven development, and end-to-end testing
  • Code quality: /code-review, /build-fix, /refactor-clean for review and remediation
  • Multi-agent: /multi-plan, /multi-execute, /orchestrate for coordinating parallel agent work
  • Learning: /learn-eval, /evolve for pattern extraction and skill evolution

Rules are always-loaded guidelines organized by language β€” common conventions plus language-specific sets for TypeScript, Python, Go, Swift, PHP, and more. These cover coding style, git workflow, testing requirements (80% TDD coverage is the default), performance patterns, and security practices.

Layer 2: Intelligence β€” Agents and Skills

This is where Claude Code configuration gets interesting. ECC defines 25+ specialized agents with explicit responsibility boundaries and restricted tool permissions:

  • Orchestrators (Planner, Architect) get broad tool access and can delegate to other agents
  • Quality agents (Code Reviewer, Security Reviewer, Database Reviewer) operate read-only
  • Builders (TDD Guide, Build Error Resolver, E2E Runner) handle implementation
  • Language specialists (Go Reviewer, Python Reviewer) provide targeted analysis

108+ Claude Code skills are domain knowledge modules loaded on demand β€” they don’t consume context tokens until invoked. Skills cover backend patterns, frontend patterns, database migrations, API design, Docker, deployment, security scanning, and framework-specific workflows for Django, Laravel, Spring Boot, Swift, C++, and Perl.

The agent/skill separation is clean: agents define who does work and what permissions they have; skills define domain knowledge and procedures.

Layer 3: Automation β€” Hooks and Scripts

Event-driven hooks fire at lifecycle stages β€” PreToolUse, PostToolUse, SessionStart, SessionEnd, PreCompact, and Stop. These are cross-platform Node.js scripts (earlier versions used fragile bash one-liners) with runtime controls:

ECC_HOOK_PROFILE=minimal|standard|strict
ECC_DISABLED_HOOKS=hook1,hook2

This means quality gates run automatically before tool execution, results get verified after execution, context loads at session start, and patterns get extracted at session end β€” without manual intervention.

Layer 4: Learning β€” The Novel Part

This is what separates Everything Claude Code from a well-organized dotfiles repo.

The Continuous Learning System

ECC implements cross-session knowledge accumulation in two generations:

Version 1 (skill-based) extracts coding patterns via Stop hooks at session end and stores them in ~/.claude/skills/learned/. It covers roughly 50–80% of learnable patterns.

Version 2 (instinct-based) is more ambitious. It achieves 100% coverage through PreToolUse and PostToolUse hooks that observe every tool interaction. Each learning unit is an “Instinct” β€” a micro-pattern with a confidence score ranging from 0.3 to 0.9. When the system accumulates 3+ related instincts, the /evolve command aggregates them into a reusable Skill module.

The practical effect: your Claude Code setup gets measurably better the more you use it. Patterns that work get reinforced. Patterns that fail get downweighted. Teams can import and export instinct libraries, which means one developer’s hard-won patterns transfer to the entire team.

This is a genuinely novel contribution to the AI coding assistant setup space. Most configuration systems are static β€” you set them up once and maintain them manually. ECC’s learning layer is dynamic and self-improving.

Why Enterprise Teams Should Care

Cross-Harness Compatibility

While born for Claude Code, ECC now works across Claude Code, Codex (OpenAI), Cursor, OpenCode, Cowork, and Antigravity. The same skills, agents, and patterns transfer across tooling. For teams evaluating multiple AI coding assistants or hedging against vendor lock-in, this is significant β€” your AI agent harness investment isn’t tied to a single platform.

Security: AgentShield

The AgentShield integration (/security-scan) provides 1,282 tests and 102 security rules specifically designed for AI agent systems. This isn’t generic SAST β€” it targets the emerging attack surface unique to agentic AI: prompt injection, tool misuse, privilege escalation through agent delegation, and data exfiltration via context windows.

AgentShield was featured at Cerebral Valley Γ— Anthropic events and addresses a real gap. As AI agents move into production with access to filesystems, APIs, and databases, purpose-built security scanning becomes essential.

Production Validation

ECC isn’t theoretical. It’s validated by:

  • Winning an Anthropic hackathon β€” building a complete product in 8 hours
  • 10+ months of daily production use building real products
  • 997 internal tests covering agents, skills, hooks, and packaging
  • 84,000+ stars and 30+ contributors providing continuous feedback
  • Two viral guides (shorthand and longform) with 3M+ tracked views and an estimated 10M+ cross-platform reach

Getting Started

ECC installs via npm with cross-platform support:

  1. Clone the repo or install via ecc-universal (the npm package)
  2. Choose a hook profile β€” minimal for low overhead, standard for most teams, strict for maximum quality gates
  3. Start with the core commands: /plan for task decomposition, /tdd for test-driven development, /code-review for automated review
  4. Let the continuous learning system (v2 instincts) build your team’s pattern library over time
  5. Run /security-scan via AgentShield before shipping anything with agent access to production systems

The repo includes Claude Code plugins via a GitHub Marketplace app with free, pro, and enterprise tiers. Contribution templates exist for agents, skills, commands, rules, hooks, and translations.

The two guides Affaan authored β€” the Shorthand Guide (setup and philosophy) and the Longform Guide (token optimization, memory persistence, evals, parallelization) β€” are essential reading before diving into customization.

Our Take

At Big Hat Group, we work with enterprise teams deploying AI agents through OpenClaw and similar platforms. ECC’s architecture maps directly to patterns we use daily β€” OpenClaw already runs a similar skills system, and many ECC skills are directly compatible.

The four-layer model (interaction β†’ intelligence β†’ automation β†’ learning) is the clearest mental framework we’ve seen for thinking about agent harness engineering as a discipline. Before ECC, configuring AI coding assistants was ad-hoc β€” scattered tips, individual config files, forum posts. ECC formalized it into something structured and transferable.

If your team is using Claude Code, Codex, or any comparable AI coding assistant, evaluate Everything Claude Code’s patterns. You don’t need to adopt the entire system β€” even cherry-picking the agent delegation model or the continuous learning architecture will improve your AI-assisted development workflow.

The repo is MIT-licensed and actively maintained: github.com/affaan-m/everything-claude-code.