Everything Claude Code: The Complete Guide to Supercharging Your AI Coding Agent
What if your AI coding assistant could learn your patterns automatically, enforce code quality at write-time, scan for security vulnerabilities, and orchestrate multi-agent workflows — all without switching tools? Everything Claude Code (ECC) is the most comprehensive performance optimization system for AI agent harnesses, providing 60+ production-ready skills, 30+ slash commands, 12+ specialized subagents, hook automations, security scanning, and continuous learning — all working across Claude Code, Codex, Cursor, and OpenCode.
With over 62,000 GitHub stars, 7,700+ forks, 57 contributors, 10 releases, and an Anthropic Hackathon win, ECC has become the de facto standard for developers who want to squeeze maximum performance out of their AI coding tools. It's not just a config pack — it's a complete system evolved over 10+ months of intensive daily use building real products.
Everything Claude Code on GitHub
What Is Everything Claude Code?
ECC is a harness performance optimization system — not an AI coding tool itself, but a plugin that dramatically improves how AI coding agents work. Think of it like a professional tuning package for your AI assistant: it adds specialized agents, battle-tested workflows, automated quality gates, security scanning, and a learning system that gets better over time.
The key insight behind ECC is that AI coding agents like Claude Code are powerful but generic out of the box. They need:
- Skills — domain-specific workflows for frontend, backend, testing, security, DevOps
- Rules — always-follow coding guidelines to prevent common mistakes
- Hooks — automated triggers that run on tool events (like warning about
console.login production code) - Agents — specialized subagents for delegation (code reviewer, security auditor, build error resolver)
- Memory — continuous learning that extracts patterns from your coding sessions
ECC provides all of this in a single, installable package that works across four major AI coding tools.
Cross-Platform Support
One of ECC's unique strengths is that it works across four major AI coding harnesses:
| Platform | Support Level | Key Features |
|---|---|---|
| Claude Code | ✅ Full | Plugin install, hooks, skills, agents, commands, MCP configs |
| Cursor IDE | ✅ Full | DRY adapter pattern reusing Claude Code's hook scripts |
| OpenAI Codex | ✅ Full | AGENTS.md-based support, installer targeting |
| OpenCode | ✅ Full | Plugin hooks, 31+ commands |
The architectural decision that makes this possible: AGENTS.md at the root serves as the universal cross-tool file (read by all 4 tools), and the SKILL.md format with YAML frontmatter works across all platforms.
Key Concepts
Agents (12+ Specialized Subagents)
ECC ships with over 12 specialized subagents, each with limited scope and specific tools:
---
name: code-reviewer
description: Reviews code for quality, security, and maintainability
tools: ["Read", "Grep", "Glob", "Bash"]
model: opus
---
You are a senior code reviewer...
Available agents include:
- planner.md — Feature implementation planning
- architect.md — System design decisions
- tdd-guide.md — Test-driven development
- code-reviewer.md — Quality and security review
- security-reviewer.md — Vulnerability analysis
- build-error-resolver.md — Build error diagnosis
- e2e-runner.md — Playwright E2E testing
- refactor-cleaner.md — Dead code cleanup
- doc-updater.md — Documentation sync
- go-reviewer.md — Go-specific code review
- python-reviewer.md — Python-specific code review
- database-reviewer.md — Database/Supabase review
Skills (60+ Workflow Definitions)
Skills are domain-specific workflow definitions that teach your AI agent best practices. ECC includes 60+ skills organized into categories:
Coding Standards & Patterns:
coding-standards/— Language best practicesfrontend-patterns/— React, Next.js patternsbackend-patterns/— API, database, caching patternsgolang-patterns/,python-patterns/,django-patterns/springboot-patterns/,cpp-coding-standards/postgres-patterns/,jpa-patterns/,docker-patterns/
Testing & Quality:
tdd-workflow/— TDD methodologyverification-loop/— Continuous verificationeval-harness/— Verification loop evaluatione2e-testing/— Playwright E2E patternsgolang-testing/,python-testing/,django-tdd/
Advanced Workflows:
continuous-learning-v2/— Instinct-based learning with confidence scoringstrategic-compact/— Manual compaction suggestionssearch-first/— Research-before-coding workflowautonomous-loops/— Sequential pipelines, PR loops, DAG orchestrationcost-aware-llm-pipeline/— LLM cost optimization and model routing
Business & Content:
article-writing/— Long-form writing without AI tonecontent-engine/— Multi-platform social contentmarket-research/— Source-attributed market researchinvestor-materials/— Pitch decks and financial modelsfrontend-slides/— HTML presentation builder
Slash Commands (30+)
Quick-access commands for common workflows:
/tdd # Test-driven development
/plan # Implementation planning
/code-review # Quality review
/build-fix # Fix build errors
/e2e # E2E test generation
/security-scan # Run AgentShield security scan
/refactor-clean # Dead code removal
/learn # Extract patterns mid-session
/instinct-status # View learned instincts
/evolve # Cluster instincts into skills
/orchestrate # Multi-agent coordination
/harness-audit # Audit harness configuration
/quality-gate # Quality gate check
/model-route # Model routing
Hooks (Automated Triggers)
Hooks fire on tool events — for example, warning about console.log:
{
"matcher": "tool == \"Edit\" && tool_input.file_path matches \"\\\\.(ts|tsx|js|jsx)$\"",
"hooks": [{
"type": "command",
"command": "#!/bin/bash\ngrep -n 'console\\.log' \"$file_path\" && echo '[Hook] Remove console.log' >&2"
}]
}
ECC includes hooks for session lifecycle management, memory persistence, strategic compaction, and pattern evaluation. Runtime controls let you adjust without editing files:
ECC_HOOK_PROFILE=minimal|standard|strict
ECC_DISABLED_HOOKS=hook1,hook2
Rules (Always-Follow Guidelines)
Organized into common/ (language-agnostic) and language-specific directories:
- coding-style.md — Immutability, file organization
- git-workflow.md — Commit format, PR process
- testing.md — TDD, 80% coverage requirement
- performance.md — Model selection, context management
- security.md — Mandatory security checks
- hooks.md — Hook architecture patterns
- agents.md — When to delegate to subagents
- Plus TypeScript, Python, and Go-specific rules
Ecosystem Tools
AgentShield — Security Auditor
Built at the Claude Code Hackathon (Cerebral Valley × Anthropic, Feb 2026). 1,282 tests, 98% coverage, 102 static analysis rules.
# Quick scan (no install needed)
npx ecc-agentshield scan
# Auto-fix safe issues
npx ecc-agentshield scan --fix
# Deep analysis with three Opus 4.6 agents
npx ecc-agentshield scan --opus --stream
# Generate secure config from scratch
npx ecc-agentshield init
What it scans: CLAUDE.md, settings.json, MCP configs, hooks, agent definitions, and skills across 5 categories — secrets detection (14 patterns), permission auditing, hook injection analysis, MCP server risk profiling, and agent config review.
The --opus flag runs three Claude Opus 4.6 agents in a red-team/blue-team/auditor pipeline: the attacker finds exploit chains, the defender evaluates protections, and the auditor synthesizes both into a prioritized risk assessment. This is adversarial reasoning, not just pattern matching.
Plankton — Write-Time Code Quality Enforcement
Plankton runs formatters and 20+ linters on every file edit via PostToolUse hooks, then spawns Claude subprocesses to fix issues the main agent missed.
Three-phase architecture:
- Auto-format silently (handles 40-50% of issues)
- Collect remaining violations as structured JSON
- Delegate fixes to a Claude subprocess (routed to Haiku/Sonnet/Opus by violation complexity)
Supports Python, TypeScript, Shell, YAML, JSON, TOML, Markdown, and Dockerfile. Includes config protection hooks that prevent agents from modifying linter configs to pass instead of fixing code.
Continuous Learning v2 (Instinct System)
The instinct-based learning system automatically extracts patterns from your coding sessions:
/instinct-status # Show learned instincts with confidence
/instinct-import <file> # Import instincts from others
/instinct-export # Export your instincts for sharing
/evolve # Cluster related instincts into skills
The system learns what works for your codebase and coding style, building up a personalized knowledge base that improves over time.
Skill Creator
Generate skills from your repository's git history:
/skill-create # Analyze current repo
/skill-create --instincts # Also generate instincts
Or use the GitHub App for advanced features (10k+ commits, auto-PRs, team sharing).
Quick Start
Install as Plugin (Recommended)
# In Claude Code CLI:
/install-plugin https://github.com/affaan-m/everything-claude-code
# Install rules (required):
cp -r rules/common/* ~/.claude/rules/
cp -r rules/typescript/* ~/.claude/rules/ # or python/, golang/
# Start using:
/plan "Add user authentication"
/tdd
/code-review
Manual Installation
Clone the repo and copy the components you need into your project.
Token Optimization
Claude Code can be expensive without proper token management. ECC provides strategies:
Recommended Settings (~/.claude/settings.json):
{
"model": "sonnet",
"env": {
"MAX_THINKING_TOKENS": "10000",
"CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "50"
}
}
Context Window Management:
- Keep under 10 MCPs enabled per project
- Keep under 80 tools active
- Use
disabledMcpServersin project config to disable unused servers - Each MCP tool description consumes tokens, potentially reducing your 200K window to ~70K
Strategic Compaction — compact at logical breakpoints:
- ✅ After research, before implementation
- ✅ After completing a milestone, before starting the next
- ✅ After debugging, before continuing feature work
- ❌ Never mid-implementation (you'll lose variable names, file paths, partial state)
ECC vs Alternatives
ECC competes with other AI agent configuration and skill ecosystems. Each has genuine strengths:
| Feature | Everything Claude Code | Antigravity Awesome Skills | Awesome Claude Code (Lists) | Aider Config Ecosystem | RooCode Rules |
|---|---|---|---|---|---|
| Skills/Resources | 60+ integrated | 1,200+ aggregated | Large curated list | Community configs | Custom rules |
| Specialized Agents | 12+ subagents | ❌ | ❌ | ❌ | ✅ Custom modes |
| Hook Automations | ✅ Full system | ❌ | ❌ | ❌ | ❌ |
| Security Scanning | ✅ AgentShield | ❌ | ❌ | ❌ | ❌ |
| Code Quality | ✅ Plankton | ❌ | ❌ | ✅ Built-in linting | ❌ |
| Continuous Learning | ✅ Instincts | ❌ | ❌ | ❌ | ✅ Memory Bank |
| Cross-Platform | 4 tools | 6+ tools | Claude Code | Multi-model native | Multi-model native |
| Token Optimization | ✅ Strategic compaction | ❌ | Tips | ✅ Built-in | ❌ |
| Community Size | 62K ⭐ | Growing | Large ecosystem | 18K+ ⭐ | Fast-growing |
| Test Suite | 997 tests | ❌ | ❌ | ✅ Comprehensive | ❌ |
| Setup Simplicity | Plugin install | Copy skills | Browse & pick | ✅ pip install | ✅ Simple config |
When to choose ECC: You want a complete, integrated performance system with hooks, security, quality enforcement, and continuous learning — especially if you use Claude Code as your primary tool.
When to choose Antigravity Awesome Skills: You want the largest catalog of skills (1,200+) from multiple providers (Anthropic, Google, Microsoft, OpenAI) across 6+ tools, with freedom to pick and choose without an opinionated system.
When to choose Awesome Claude Code lists: You want a curated, regularly-updated directory of the best resources, tools, and configs — great for discovering what's available.
When to choose Aider: You want a mature, battle-tested CLI tool with native git integration, multi-model support, and built-in token optimization — 18K+ stars and a strong open-source community.
When to choose RooCode: You want a flexible agent system with custom modes, a Memory Bank for persistent context, and multi-model support with your own API keys.
Version History
| Version | Date | Key Features |
|---|---|---|
| v1.8.0 | Mar 2026 | Harness Performance System, hook reliability overhaul, NanoClaw v2, 997 tests |
| v1.7.0 | Feb 2026 | Cross-platform expansion, 5 business skills, Codex app support, 992 tests |
| v1.6.0 | Feb 2026 | Codex CLI, AgentShield (1,282 tests), GitHub Marketplace, 978 tests |
| v1.4.0 | Feb 2026 | Multi-language rules, installation wizard, PM2 support |
| v1.3.0 | Feb 2026 | OpenCode plugin support |
| v1.2.0 | Feb 2026 | Unified commands and skills |
FAQ
What is Everything Claude Code?
ECC is a performance optimization system for AI coding agent harnesses. It provides skills, agents, hooks, rules, security scanning, and continuous learning that work across Claude Code, Codex, Cursor, and OpenCode.
Is it just config files?
No. It's a complete system with 60+ skills, 30+ commands, 12+ agents, automated hooks, AgentShield security scanning (1,282 tests), Plankton code quality enforcement (20+ linters), and an instinct-based continuous learning system. It has 997 internal tests.
Which AI coding tools does it support?
Claude Code, Cursor IDE, OpenAI Codex (app + CLI), and OpenCode — all from the same codebase using a DRY adapter pattern.
How do I install it?
Run /install-plugin https://github.com/affaan-m/everything-claude-code in Claude Code, then copy the rules to ~/.claude/rules/.
Does it help with cost optimization?
Yes. ECC includes strategic compaction workflows, context window management guidelines, token optimization settings, and model routing to reduce costs without sacrificing quality.
Can it learn my coding patterns?
Yes. The Continuous Learning v2 system uses instinct-based pattern extraction with confidence scoring. Use /instinct-status to view learned patterns and /evolve to cluster them into reusable skills.
Is it safe?
ECC includes AgentShield, which scans for vulnerabilities, misconfigurations, and injection risks across your AI coding setup. The --opus flag runs adversarial red-team/blue-team analysis.
Is it free?
Yes. MIT licensed — free for commercial and personal use. Sponsorship tiers are available for companies that want priority support.
Conclusion
Everything Claude Code has earned its 62,000+ stars by solving a real problem: AI coding agents are powerful but generic. ECC transforms them into specialized, secure, continuously-learning development partners. The combination of 60+ battle-tested skills, AgentShield security scanning, Plankton code quality enforcement, and instinct-based continuous learning creates a system that genuinely improves over time.
Whether you're using Claude Code, Cursor, Codex, or OpenCode, ECC provides a unified, cross-platform performance layer that makes your AI coding agent significantly more productive, safer, and cost-efficient. It's the difference between using an AI assistant out of the box and using one that's been professionally tuned for real-world development.
Explore Everything Claude Code on GitHub