claudeers.
// Developer Tools

ECC-Antigravity

🚀 Everything Claude Code (ECC) for Google Antigravity. Full runtime compatibility: 68+ specialized agents, 280+ skills, and automated safety/quality lifecyc…

// Developer Tools[ cli ][ api ][ desktop ][ web ][ mobile ][ claude ]#claude#devtools◷ MIT$open-sourceupdated about 1 month ago
Actively maintained
99/100
last commit about 2 months ago
last release none
releases 0
open issues 1
// star history

Install with your AI

Paste into Claude Code, Cursor, or any agent — it reads the repo and wires the tool into your project.

Install and set up ECC-Antigravity (claude-plugin project) into my current project.
Found on https://claudeers.com/ecc-antigravity
Repo: https://github.com/cloudblower/ECC-Antigravity
Homepage/docs: —
Detected install method: claude-plugin → /plugin install ecc-antigravity@cloudblower/ECC-Antigravity
Category: devtools. Platforms: cli, api, desktop, web, mobile.
Read the repo's README for exact setup and env vars, then install it and wire it into my project.

Claudeers Health Verdict:
active; community-verified: false. Confirm the source before running anything.
// or install directly (claude-plugin)
/plugin marketplace add cloudblower/ECC-Antigravity
/plugin install ecc-antigravity@cloudblower/ECC-Antigravity
// or clone
git clone https://github.com/cloudblower/ECC-Antigravity

// compatibility

Platformscli, api, desktop, web, mobile
Operating systems—
AI compatibilityclaude
LicenseMIT
Pricingopen-source
LanguageJavaScript

Get your FREE $2.50 API credits to access TickAtlas financial data ↗

ECC-Antigravity (Everything Claude Code for Google Antigravity)

Welcome to ECC-Antigravity, a specialized, upstream-friendly edition of Everything Claude Code (ECC) engineered for full runtime compatibility with Google Antigravity!

While the upstream ECC repository provides an outstanding collection of 68+ specialized agents, 280+ workflow skills, and prompt rules, its automated runtime superpowers—the lifecycle hooks engine, real-time safety gates, session learning, and transcript telemetry—were built around Claude Code's native hook lifecycle. When using upstream ECC inside Google Antigravity, those hook workflows could not run due to differing event models, tool schemas, and transcript formats.

ECC-Antigravity bridges this gap entirely. Through a dedicated Antigravity adapter layer, schema translation bridge, and transcript shadow engine, ECC-Antigravity unlocks the complete suite of ECC runtime hooks and automated development workflows in Google Antigravity—all while preserving 100% compatibility with upstream ECC.


Feature Comparison: ecc-antigravity vs. Upstream ecc on Antigravity

Feature CategoryFeature / Hook IDUpstream ecc on Antigravityecc-antigravityNotes
Agent Skills & Prompts280+ Curated Skills & RulesSupportedSupportedFull access to ECC skills, prompts, and guidelines in .agent/skills/ and .agents/rules/
Safety & Governancepre:bash:dispatcherUnsupportedFull SupportIntercepts, inspects, and blocks hazardous shell commands before execution
pre:config-protectionUnsupportedFull SupportProtects critical configuration and credentials from accidental modification
pre:governance-captureUnsupportedFull SupportCaptures audit trails and decisions across agent executions
pre:write:doc-file-warningUnsupportedFull SupportPrevents untracked or premature creation of top-level documentation files
Code Quality & Gatespre:edit-write:gateguard-fact-forceUnsupportedFull SupportVerification gate enforcing test-first discipline and fact validation before edits
stop:format-typecheckUnsupportedFull SupportAutomatically runs batch Biome/Prettier formatting and tsc typechecking on stop
stop:check-console-logUnsupportedFull SupportDetects and prevents leaving leftover console.log debugging statements
Session & Memorystop:session-end & Delayed SessionEndUnsupportedFull SupportPersists conversation memory and schedules background session finalization
stop:evaluate-sessionUnsupportedFull SupportAnalyzes completed sessions to extract reusable patterns, instincts, and rules
pre:observe:continuous-learningUnsupportedFull SupportContinuous session observation for instinct creation and evolutionary learning
Metrics & Telemetrystop:cost-trackerUnsupportedFull SupportTracks token usage, cost metrics, and Gemini model context window utilization per turn
post:skill:trackUnsupportedFull SupportAutomatically tracks skill usage and success rates to power real-time skill health analytics and reports
pre:mcp-health-check & post:mcp-health-checkUnsupportedFull SupportMonitors MCP server health, records failures, and initiates reconnect attempts
Feedback & UXstop:plan-canvas-pendingUnsupportedFull SupportFlushes pending Plan Canvas browser annotations directly into the agent context
stop:desktop-notifyUnsupportedNative AGY Built-inDisabled in adapter because Google Antigravity provides native, built-in IDE notifications
Context Managementpre:compact (Compaction Hook)UnsupportedPlanned / ReadyBecause Gemini models feature large context windows (1M+ tokens), Google Antigravity has not added support for context compaction yet; ecc-antigravity is prepared to support it once introduced

Quick Start with ecc-antigravity

Google Antigravity 2.0 discovers workspace customizations from the project-local .agents/ directory. ecc-antigravity installs native rules, workflows, skills, adapted custom agents, and the complete Antigravity runtime hooks engine directly into your workspace.

1. Step-by-Step Installation

Follow these step-by-step instructions to clone ecc-antigravity into your home directory and install it into your project workspace:

Step 1: Clone ecc-antigravity to your home folder

macOS / Linux:

git clone https://github.com/cloudblower/ecc-antigravity.git ~/.ecc-antigravity

Windows (PowerShell):

git clone https://github.com/cloudblower/ecc-antigravity.git "$HOME\.ecc-antigravity"

Step 2: Navigate to your target project workspace

Always run the installer from the root directory of the project you want to configure:

macOS / Linux:

cd /path/to/your-project

Windows (PowerShell):

cd C:\path\to\your-project

Step 3: Run the installer

We recommend Option A (Core profile) for most projects to get the essential skills, safety rules, and runtime hooks:

macOS / Linux (Shell Script):

# Option A (Recommended): Core profile (essential skills, safety rules, and runtime hooks)
~/.ecc-antigravity/install.sh --target antigravity --profile core

# Option B: Full profile (all 68+ agents, 280+ skills, and all hook automations)
~/.ecc-antigravity/install.sh --target antigravity --profile full

# Option C: Minimal profile + specific language packs
~/.ecc-antigravity/install.sh --target antigravity typescript python go

Windows (PowerShell):

# Option A (Recommended): Core profile (essential skills, safety rules, and runtime hooks)
& "$HOME\.ecc-antigravity\install.ps1" --target antigravity --profile core

# Option B: Full profile
& "$HOME\.ecc-antigravity\install.ps1" --target antigravity --profile full

# Option C: Minimal profile + specific language packs
& "$HOME\.ecc-antigravity\install.ps1" --target antigravity typescript python go

2. Native Antigravity 2.0 Install Mapping

ecc-antigravity maps source assets cleanly into the canonical .agents/ structure:

ECC SourceAntigravity DestinationPurpose & Behavior
rules/.agents/rules/Workspace coding & safety rules (flattened, collision-safe)
commands/.agents/workflows/User-invoked slash workflows (e.g. /plan, /review)
skills/<name>/.agents/skills/<name>/280+ Agent Skills with required SKILL.md
agents/<name>.md.agents/agents/<name>.mdCustom main agents and subagents
hooks/.agents/hooks/Hook trigger definitions and lifecycle scripts
scripts/.agents/scripts/Cross-platform utilities, telemetry helpers, and runtime adapter scripts
hooks/agy-hooks.json.agents/hooks.jsonActive runtime hook configuration for safety gates and lifecycle automation

3. Verify the Installation

Confirm everything is installed and discoverable in your project:

macOS / Linux:

# Inspect installed components
node ~/.ecc-antigravity/scripts/list-installed.js --target antigravity

# Run health doctor check
node ~/.ecc-antigravity/scripts/doctor.js --target antigravity

Windows (PowerShell):

node "$HOME\.ecc-antigravity\scripts\list-installed.js" --target antigravity
node "$HOME\.ecc-antigravity\scripts\doctor.js" --target antigravity

4. Activate

Start a new conversation in Google Antigravity so the agent receives the updated skill inventory and initializes the hook runtime.

[!NOTE] While ecc-antigravity is optimized with dedicated runtime hooks for Google Antigravity, it preserves 100% full compatibility with all other harnesses: you can also use ecc-antigravity to install for Claude Code, Codex, Cursor, or any other supported harness by following the upstream instructions below. The upstream ecc README is preserved below for reference.


ECC - the agent harness operating system

GitHub Trending Repository of the Day Star History Global Rank

Language: English | Português (Brasil) | 简体中文 | 繁體中文 | 日本語 | 한국어 | Türkçe | Русский | Tiếng Việt | ไทย | Deutsch | Español

[!WARNING] Official sources only. Install ECC only from verified channels: the GitHub repository github.com/affaan-m/ECC, the npm packages ecc-universal and ecc-agentshield, the GitHub App, the plugin slug ecc@ecc, and the project website ecc.tools. Third-party re-uploads and unofficial mirrors are not maintained or reviewed by the project and may contain malware.

Install with Claude Code

Run these commands inside Claude Code:

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

That installs ECC's skills, agents, commands, and plugin-managed hooks. If you choose this path, stop there. Do not also run a full manual install into Claude Code.

ECC 2.2 includes guided package setup through ecc-universal. The native Claude plugin commands above remain the simplest Claude Code install path.

ECC Tools
ECC Pro + GitHub App

Install free · Private repos from $19/seat/mo
ECC-Antigravity
Sponsor ECC

Fund the open-source project
Discord
Community

Discord · Q&A · Show and Tell

OSS stays free. This repo is MIT-licensed forever. ECC Pro is the hosted GitHub App for private repos. Sponsors and Pro subscribers fund the work. That's why a single maintainer ships weekly across 7 harnesses.

Partners & sponsors

CodeRabbit    Greptile    Atlas Cloud    Moonshot AI - Kimi    Itô Markets

Community sponsors: Mike Morgan · @jasonwu513 · @1anter · @massimotodaro · @meadmccabe

Become a Sponsor · Sponsor Tiers · Sponsorship Program

Jump to install ↓

ECC

Your agent can write code, but ECC gives it a coordinated engineering system and toolbox: it plans before it builds, verifies changes with tests, reviews its own work from a fresh context, remembers what matters, and turns repeated wins into reusable skills and workflows.

plan -> test -> implement -> review -> verify -> remember -> improve

Instead of rebuilding that process in every prompt, you install it once and make it part of how your agent works.

Optimize the context window. Persist everything else.

ECC is MIT-licensed open source. It works best with Claude Code today, has a supported Codex sync path, and provides capability-limited adapters for Cursor, OpenCode, Gemini, Zed, GitHub Copilot, Antigravity, Qwen, and other harnesses. See the support status matrix before assuming feature parity.

Access to 68 agents, 286 skills, and 94 legacy command shims, plus hooks, rules, memory, continuous learning, and AgentShield security scanning. The agents are specialized for planning, review, build repair, security, architecture, and domain work.

IncludedCountWhat it gives you
Agents68 agentsPlanning, review, build repair, security, architecture, and domain work
Skills286 skillsTDD, research, security, docs, frontend, data, ML, operations, and more
Commands94 commandsConvenient entry points while ECC moves to a skills-first surface
Hooks and memoryRuntimeEnforcement, session summaries, continuous learning, instincts, and context controls
RulesSelectiveAlways-loaded standards you choose by language or project
AgentShieldIncludedScanning for prompts, hooks, MCP config, permissions, secrets, and agent files

ECC star history: first 40,000 stars, January 18 to February 7, 2026

Install ECC

[!IMPORTANT] ECC 2.2 includes guided package setup for Claude Code, Codex, and Kimi Code. During registry propagation, run npm view ecc-universal version before using the package commands. If it still reports 2.1.0, the native Claude plugin commands at the top of this README remain available.

Pick one path only (per harness)

You can use ECC with Claude Code, Codex, and other harnesses at the same time. Choose one install method for each harness:

  • Recommended default: run the guided Claude plugin setup below once npm view ecc-universal version reports 2.2.0
  • Available throughout npm propagation: use the native plugin commands above
  • Available in release 2.2: guided package setup for Claude Code, Codex, and Kimi Code
  • Works: Claude Code plugin + Codex native plugin
  • Works: Claude Code plugin + the legacy Codex sync flow
  • Avoid: Claude Code plugin + full Claude manual install
  • Avoid: Codex sync + Codex marketplace plugin

Do not stack install methods. Installing ECC twice into the same harness can duplicate skills, commands, hooks, or configuration; installing it once into multiple harnesses does not.

If you already layered multiple installs and things look duplicated, skip straight to Reset / Uninstall ECC.

Install trouble? Open the short install or runtime problem form, or run ecc feedback. ECC never uploads diagnostics automatically.

Claude Code details

Claude Code owns these built-in commands, including their errors when a marketplace, plugin, or conflicting scope already exists. ECC cannot intercept that parser. If either native command reports an existing install or scope conflict, use the 2.2 guided setup or resolve the conflicting Claude plugin scope before retrying; do not layer a manual install on top.

After ECC is installed, /ecc:configure-ecc is the namespaced in-Claude reconfiguration skill. It delegates to the same safe setup flow, but it is available only after the plugin is installed and cannot replace Claude Code's built-in /plugin command during a first install.

Claude Code plugins cannot distribute rules, so add only the rule packs you actually want:

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/typescript ~/.claude/rules/ecc/  # replace with your stack

Start with rules/common plus one language or framework pack you actually use. If you install the plugin, do not run ./install.sh --profile full afterward.

Prefer settings.json? Add the marketplace declaratively

Add directly to your ~/.claude/settings.json:

{
  "extraKnownMarketplaces": {
    "ecc": {
      "source": {
        "source": "github",
        "repo": "affaan-m/ECC"
      }
    }
  },
  "enabledPlugins": {
    "ecc@ecc": true
  }
}

This gives you the same result as the two /plugin commands above.

Naming + migration note (ecc@ecc, affaan-m/ECC, ecc-universal)

ECC has three public identifiers, and they are not interchangeable:

  • GitHub source repo: affaan-m/ECC
  • Claude marketplace/plugin identifier: ecc@ecc
  • npm package: ecc-universal

This is intentional. Anthropic marketplace/plugin installs are keyed by a canonical plugin identifier, so ECC uses ecc@ecc to keep tool names and slash-command namespaces short enough for strict Desktop/API validators. Older posts may still show the former long marketplace identifier; treat that as a legacy alias only. Separately, the npm package stayed on ecc-universal, so npm installs and marketplace installs intentionally use different names.

npm releases are cut per version tag, not per commit, so ecc-universal tracks releases (2.1, 2.2, ...) rather than every push to main. Install from git if you want the bleeding edge.

If your local Claude setup was wiped or reset, that does not mean you need to repurchase anything. Start with node scripts/ecc.js list-installed, then run node scripts/ecc.js doctor and node scripts/ecc.js repair before reinstalling. That usually restores ECC-managed files without rebuilding your setup.

Codex App and CLI

Current Codex releases can install ECC as a native repo-marketplace plugin. The marketplace entry uses the repository root so Codex's cache receives the manifest together with all referenced skills, MCP configuration, hook runtime, scripts, and assets:

codex plugin marketplace add affaan-m/ECC
codex plugin add ecc@ecc
codex plugin list --json
node scripts/codex/check-plugin-cache.js

Both add commands are idempotent. To refresh later, run codex plugin marketplace upgrade ecc followed by codex plugin add ecc@ecc. Codex stores one enabled plugin state in the active CODEX_HOME; it does not offer Claude's user, project, and local scopes. Its native hooks require an explicit trust decision and do not use Claude's four ECC hook profiles. Inside Codex, invoke $configure-ecc for the guided provider-aware flow.

The older scripts/sync-ecc-to-codex.sh path is a deprecated compatibility option for users who intentionally need copied and merged configuration in ~/.codex; it is not required for the native plugin. New sync runs write an ownership manifest so cleanup can preserve modified user files. Run Codex once first so ~/.codex/config.toml exists, then:

git clone https://github.com/affaan-m/ECC.git
cd ECC
npm install
bash scripts/sync-ecc-to-codex.sh

To inspect or remove that legacy layer without touching Codex conversations or native plugin caches:

node scripts/ecc.js uninstall --legacy-codex-sync --dry-run
node scripts/ecc.js uninstall --legacy-codex-sync

Pre-manifest installations are handled conservatively: ECC removes its marked AGENTS.md block but preserves copied files it cannot prove it owns and reports them for review.

You can also open the ECC repository directly in Codex for a project-local setup. Codex reads the root AGENTS.md and the trusted project configuration in .codex/ without a global sync. Do not add the native marketplace plugin on top of the sync flow.

For repo navigation, surface ownership, and PR diff packet guidance, read the Codex ECC Navigation Map. See the .codex plugin notes for native lifecycle details.

Other agents and editors

Cursor, OpenCode, Gemini, Zed, Antigravity, Qwen, Hermes, OpenClaw, Kimi, CodeBuddy, JoyCode, Copilot

Clone ECC once, then choose the target that matches your harness:

git clone https://github.com/affaan-m/ECC.git
cd ECC
HarnessInstall or setupNotes
Cursor./install.sh --profile minimal --target cursorProject-local .cursor/ adapter
OpenCodenpm install && npm run build:opencode && ./install.sh --profile full --target opencodeBuilds the plugin payload before the full install
Gemini CLI./install.sh --profile minimal --target geminiProject-local .gemini/ config
Zed./install.sh --profile minimal --target zedProject-local .zed/ adapter
Antigravity./install.sh --profile minimal --target antigravitySee the Antigravity guide
Qwen CLI./install.sh --profile minimal --target qwenSee the Qwen guide
Hermes./install.sh --profile minimal --target hermesSee the Hermes setup guide
OpenClaw./install.sh --profile minimal --target openclawManaged home-directory install
Kimi Code CLI./install.sh --profile minimal --target kimiProject-local .kimi-code/ install
CodeBuddy./install.sh --profile minimal --target codebuddyProject-local .codebuddy/ install
JoyCode./install.sh --profile minimal --target joycodeProject-local .joycode/ install

GitHub Copilot support is already included in this repository. .github/copilot-instructions.md provides the instruction layer, .github/prompts/ contains the reusable /plan, /tdd, /security-review, /build-fix, and /refactor prompts, and .vscode/settings.json enables chat.promptFiles.

For a harness without a native ECC target, use the manual adaptation guide. It explains how to carry a small set of ECC skills and workflow instructions into chat-style tools without pretending hooks or native skill discovery are available.

Cursor installs agent definitions under .cursor/agents/ecc-*.md. Cursor-native loading behavior can vary by Cursor build. ECC does not install root AGENTS.md into .cursor/. The adapter keeps Cursor's context scoped to its native rules and agent surfaces.

Deep per-harness notes (feature parity, hook adapters, limitations) live in Platform Support below.

Self-Hosted Models and Custom Endpoints

ECC works through each harness's normal configuration, so you can use an official provider, a compatible custom API endpoint or model gateway, or a self-hosted model without changing ECC's workflows.

For Claude Code, ECC does not hardcode Anthropic-hosted transport settings. Minimal gateway example:

export ANTHROPIC_BASE_URL=https://your-gateway.example.com
export ANTHROPIC_AUTH_TOKEN=your-token
claude

If your gateway remaps model names, configure that in Claude Code rather than in ECC. ECC's hooks, skills, commands, and rules are model-provider agnostic once the claude CLI is already working. See Anthropic's LLM gateway documentation and model configuration documentation.

Run or self-host any open-source model behind that gateway using separate compute and serving setup. If you need GPU capacity, Itô is ECC's preferred compute sponsor; any GPU provider works. The sponsorship link is passive: it does not invoke an RFQ, reserve capacity, provision compute, or configure serving. Separately, ecc ito find invokes the explicitly configured canonical Itô CLI and submits a live authenticated RFQ; it does not reserve capacity. Managed inference through Itô is not live yet.

Self-host Kimi with ECC + Itô compute

The Kimi Code harness and the model-serving layer are separate. ECC configures the agent harness; you bring an API endpoint or self-host an open-weight Kimi model on your own GPU capacity. This adapter is verified against Kimi Code 0.31.x (@moonshot-ai/kimi-code):

Itô Markets
1. Get GPU capacity

Use Itô or any GPU provider.
Moonshot AI - Kimi
2. Serve Kimi

Expose the chosen checkpoint through a compatible endpoint.
ECC Tools
3. Run Kimi Code with ECC

Install project instructions and skills, then start Kimi Code.

Configure the endpoint with Kimi Code's official provider guide, then install ECC:

bash ./install.sh --target kimi --profile minimal
node scripts/ecc.js doctor --target kimi
kimi

Kimi Code discovers the installed .kimi-code/AGENTS.md instructions and .kimi-code/skills/ workflows natively; project-level .agents/skills/ is also an official discovery location. ECC safely merges project MCP entries into .kimi-code/mcp.json and does not change the user-level ~/.kimi-code/config.toml. Kimi Code supports native hooks, but ECC's current managed-project adapter does not configure them, so this installer does not offer Kimi hook profiles. The installer dry-run and regression suite verify that every managed Kimi write stays inside the project-local .kimi-code/ root.

Itô compute CLI bridge

ecc ito delegates to the separately installed canonical Itô client; ECC does not maintain a second API client. ecc ito login [--no-browser] performs device authorization, opens the Itô verification page by default, and persists a device token in macOS Keychain; --no-browser suppresses the page handoff. ECC itself does no browser automation. ecc ito auth is validation-only and rejects --no-browser. The available operations are ecc ito login, ecc ito auth, ecc ito find, ecc ito status, and the separately gated ecc ito evals. The matching MCP tools remain ito_auth, ito_find, and ito_status; ito_auth validates existing credentials and node qualification is CLI-only.

The ito-compute-cli package is currently unpublished. Build it locally from the Itô runtime repo (private while the desk hardens; design partners get access) under cli/ito-compute-cli, run npm ci and npm run check, then set ECC_ITO_CLI_EXECUTABLE to that build's absolute dist/bin/ito.js path. Login never inherits ITO_API_KEY; auth, find, and status forward ITO_API_KEY directly when configured, and ITO_AUTH_MODE=legacy is not required. ecc ito logout revokes the current device credential and retains its local copy if remote revocation cannot be confirmed. Device tokens use macOS Keychain by default; explicit file fallback must retain owner-only directory/file permissions. ECC does not discover this credential-bearing client through PATH. See the ito-compute skill for the full RFQ authority and MCP setup contract.

find submits a live authenticated RFQ. It does not reserve capacity. evals requires both ITO_ENABLE_SIXTYTWO_LIVE=1 and --live-sixtytwo, a separately installed sixtytwo-cli==0.3.33, an explicit node list, and an existing absolute configuration directory. It cannot rent, launch, recover, repair, or purchase. ECC exposes no quote lock, purchase, workload, or inference path, and it never replaces a missing client or failed live call with a local result.

Advanced Install Options

The options stay here, directly under the main install paths, so you do not have to hunt through the README when the default setup is not the right fit.

Low-context install with no hook runtime

Low-context / no-hooks path

Use this when you want ECC's rules, agents, commands, platform config, and core workflows without runtime hooks:

./install.sh --profile minimal --target claude

Windows:

.\install.ps1 --profile minimal --target claude

This profile intentionally excludes hooks-runtime.

Claude manual installs place each skill directly under ~/.claude/skills/<skill-name>/ (or .claude/skills/<skill-name>/ for claude-project) so Claude Code can discover it. When upgrading an older ECC manual install, the installer migrates only nested skills/ecc/ files recorded in ECC install-state. If a flat skill directory is user-owned, ECC preserves it, prints a conflict warning, and keeps any older managed copy tracked for a safe uninstall instead of overwriting user files.

For the normal core profile with hooks disabled:

./install.sh --profile core --without baseline:hooks --target claude

Add the hook runtime later only if you want it:

./install.sh --target claude --modules hooks-runtime
Choose only the components you need

Find the right components first

Ask the packaged advisor which components match your work:

node scripts/ecc.js consult "security reviews" --target claude

It returns matching components, related profiles, and preview/install commands. Use the preview command before installing if you want to inspect the exact file plan.

You can also install explicit skills or capabilities:

./install.sh --target claude --skills tdd-workflow,security-review
node scripts/ecc.js install --profile minimal --target claude --with capability:machine-learning

Manual component-by-component copying also works. Each component is fully independent:

# Just agents
cp agents/*.md ~/.claude/agents/

# Rules directories (common + language-specific)
mkdir -p ~/.claude/rules/ecc
cp -r rules/common ~/.claude/rules/ecc/
cp -r rules/typescript ~/.claude/rules/ecc/   # pick your stack

# Core/general skills only (Claude Code loads skills from direct children
# of ~/.claude/skills; do not nest manual installs under ~/.claude/skills/ecc/)
mkdir -p ~/.claude/skills
cp -r .agents/skills/* ~/.claude/skills/
cp -r skills/search-first ~/.claude/skills/

# Optional: maintained slash-command compatibility during migration
mkdir -p ~/.claude/commands
cp commands/*.md ~/.claude/commands/

Retired shims live in legacy-command-shims/. Copy individual files from there only if you still need old names such as /tdd.

Project-local rules instead of global rules

Use project-local rules when ECC's standards should apply to one repository rather than every Claude Code session:

cd your-project
mkdir -p .claude/rules/ecc
cp -R /path/to/ECC/rules/common .claude/rules/ecc/
cp -R /path/to/ECC/rules/typescript .claude/rules/ecc/

Rules are always-loaded context, so begin with common and one pack for the stack you actually use. When copying rules manually, copy the whole language directory (for example rules/common or rules/golang), not the files inside it, so relative references keep working and filenames do not collide.

Fully manual Claude install

Use this only when you are intentionally skipping the plugin path:

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

Windows:

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

If you choose this path, stop there. Do not also run /plugin install.

For hand-picked manual installs, Claude discovers skills as direct children of ~/.claude/skills/; do not nest them under ~/.claude/skills/ecc/.

Install hooks

Do not copy the raw repo hooks/hooks.json into ~/.claude/settings.json or ~/.claude/hooks/hooks.json. That file is plugin/repo-oriented; use the installer so hook command paths are rewritten correctly:

bash ./install.sh --target claude --modules hooks-runtime

That writes resolved hooks to ~/.claude/hooks/hooks.json and leaves any existing ~/.claude/settings.json untouched.

If you installed ECC via /plugin install, do not copy those hooks into settings.json. Claude Code v2.1+ already auto-loads plugin hooks/hooks.json, and duplicating them in settings.json causes duplicate execution and cross-platform hook conflicts.

On Windows, Claude's config root is %USERPROFILE%\\.claude; install the hook runtime with:

pwsh -File .\install.ps1 --target claude --modules hooks-runtime

Configure MCPs

Claude plugin installs intentionally do not auto-enable ECC's bundled MCP server definitions. This avoids overlong plugin MCP tool names on strict third-party gateways while keeping manual MCP setup available.

Use Claude Code's /mcp command or CLI-managed MCP setup for live Claude Code server changes; Claude Code persists those choices in ~/.claude.json. For repo-local MCP access, copy desired MCP server definitions from mcp-configs/mcp-servers.json into a project-scoped .mcp.json.

ECC ships exactly one default connector (chrome-devtools); everything else is a skill wrapping a CLI/REST API or an opt-in catalog entry. The rule and the June 2026 audit that retired the previous six defaults live in docs/MCP-CONNECTOR-POLICY.md.

If you already run your own copies of ECC-bundled MCPs, set:

export ECC_DISABLED_MCPS="chrome-devtools"

ECC-managed install and Codex sync flows will skip or remove those bundled servers instead of re-adding duplicates. ECC_DISABLED_MCPS is an ECC install/sync filter, not a live Claude Code toggle.

Important: Replace YOUR_*_HERE placeholders with your actual API keys.

Multi-model commands require additional setup

multi-* commands are not covered by the base plugin/rules install.

To use /multi-plan, /multi-execute, /multi-backend, /multi-frontend, and /multi-workflow, you must also install the ccg-workflow runtime. Initialize it with npx ccg-workflow.

That runtime provides the external dependencies these commands expect, including:

  • ~/.claude/bin/codeagent-wrapper
  • ~/.claude/.ccg/prompts/*

Without ccg-workflow, these multi-* commands will not run correctly.

Reset, repair, or uninstall

Reset / Uninstall ECC

If ECC feels duplicated, intrusive, or broken, inspect the managed state before reinstalling:

node scripts/ecc.js list-installed
node scripts/ecc.js doctor
node scripts/ecc.js repair
node scripts/ecc.js uninstall --dry-run

For direct uninstall:

node scripts/uninstall.js --dry-run
node scripts/uninstall.js

If you are leaving, the uninstall command prints an optional 20-second feedback form. It is a public GitHub issue, never blocks uninstall, and ECC does not upload diagnostics. You can also run ecc feedback at any time to see the problem, feedback, and feature routes.

Plugin users should remove the plugin from Claude Code, then delete only the rule folders they manually copied and no longer want. ECC only removes files recorded in its install-state. It does not claim unrelated files in your harness directories.

If you stacked methods, clean up in this order:

  1. Remove the Claude Code plugin install.
  2. Run the ECC uninstall command from the repo root to remove install-state-managed files.
  3. Delete any extra rule folders you copied manually and no longer want.
  4. Reinstall once, using a single path.

Guided package setup in release 2.2

[!IMPORTANT] These package-runner commands require ecc-universal 2.2.0 or newer. Confirm registry propagation with npm view ecc-universal version. The native Claude plugin install remains available throughout npm rollout.

For Claude Code plugin setup, updates, scope changes, and hook-profile changes:

npx ecc-universal setup

ECC 2.2 supports the same guided setup through modern package runners:

Package runnerGuided setup command
npm / npxnpx ecc-universal setup
pnpmpnpm dlx ecc-universal setup
Yarn 2+yarn dlx ecc-universal setup
Bunbunx ecc-universal setup

Yarn Classic 1 does not provide yarn dlx; use npx, install the package globally, or upgrade Yarn for a temporary one-shot run.

The wizard inventories the official marketplace and every native Claude install scope before making changes, then installs, updates, or safely moves ecc@ecc to the scope you choose. Rerun the same command whenever you want to update ECC, change scope, or change its hook profile. This setup wizard currently configures the Claude Code plugin; use the multi-harness wizard below for Codex or Kimi Code.

To configure more than one coding agent in one reviewed flow, use the multi-harness wizard:

npx ecc-universal install --guided

It lets you select any combination of Claude Code, Codex, and Kimi Code, shows each install channel and destination, preflights every selection before the first write, and asks for one final confirmation.

HarnessGuided install behavior
Claude CodeNative ecc@ecc plugin with one user, project, or local scope and an ECC hook profile
CodexNative Codex marketplace/plugin lifecycle; hook review and trust remain Codex-owned
Kimi CodeManaged project files under ./.kimi-code; ECC hooks, model/provider settings, and authentication are not configured

For automation, make every provider-specific choice explicit:

npx ecc-universal install --guided \
  --harness claude --harness codex --harness kimi \
  --claude-scope local --claude-hooks standard \
  --profile core --yes

Verify the native guided Codex path and managed Kimi path without writing first:

npx ecc-universal install --guided --harness codex --dry-run
npx ecc-universal install --profile core --target kimi --dry-run

Additional package-name commands are also available through the 2.2 alias:

npx ecc-universal consult "security reviews" --target claude
npx ecc-universal install --profile minimal --target claude --with capability:machine-learning
npx ecc-universal doctor --target kimi

Do not use npx ecc-install --profile minimal --target claude: ecc-install is a binary name inside ecc-universal, not a separately published npm package.

ECC also ships advanced managed adapters for cursor, antigravity, gemini, opencode, codebuddy, joycode, qwen, zed, hermes, and openclaw. Those targets still use their documented ecc install --target ... paths until each adapter has passed the guided collision, update, repair, and uninstall lifecycle matrix. Neither wizard silently installs into every detected harness.

Start Using ECC

Start with the workflow you need, not the full catalog.

What you are doingStart here
Building a feature/ecc:plan "describe the feature", then tdd-workflow
Fixing a bugReproduce it with a failing test, then use tdd-workflow
Reviewing new code/code-review for a fresh-context review
Repairing a build/build-fix
Cleaning a codebase/refactor-clean
Checking context pressure/context-budget
Ending a long session/save-session or /learn-eval
Resuming later/resume-session
Auditing agent config/security-scan or npx -y ecc-agentshield scan --path .
Plugin commands and manual commands

Claude Code plugin commands use the namespaced form:

/ecc:plan "Add authentication"

Manual installs may expose the shorter compatibility form:

/plan "Add authentication"

Skills are the primary workflow surface. Commands remain convenient entry points and compatibility shims. Check what is installed with:

/plugin list ecc@ecc
Which agent should I use?

Skills are the canonical workflow surface; maintained slash entries stay available for command-first workflows.

I want to...Use this surfaceAgent used
Plan a new feature/ecc:plan "Add auth"planner
Design system architecture/ecc:plan + architect agentarchitect
Write code with tests firsttdd-workflow skilltdd-guide
Review code I just wrote/code-reviewcode-reviewer
Fix a failing build/build-fixbuild-error-resolver
Run end-to-end testse2e-testing skille2e-runner
Find security vulnerabilities/security-scansecurity-reviewer
Remove dead code/refactor-cleanrefactor-cleaner
Update documentation/update-docsdoc-updater
Review Go code/go-reviewgo-reviewer
Review Python code/python-reviewpython-reviewer
Review F# code(invoke fsharp-reviewer directly)fsharp-reviewer
Review TypeScript/JavaScript code(invoke typescript-reviewer directly)typescript-reviewer
Develop HarmonyOS apps(invoke harmonyos-app-resolver directly)harmonyos-app-resolver
Audit database queries(auto-delegated)database-reviewer
Review production ML changesmle-workflow skill + mle-reviewer agentmle-reviewer
Common workflows

Slash forms below are shown where they remain part of the maintained command surface. Retired short-name shims such as /tdd and /eval live in legacy-command-shims/ for explicit opt-in only.

Starting a new feature:

/ecc:plan "Add user authentication with OAuth"
                                              -> planner creates implementation blueprint
tdd-workflow skill                            -> tdd-guide enforces write-tests-first
/code-review                                  -> code-reviewer checks your work

Fixing a bug:

tdd-workflow skill                            -> tdd-guide: write a failing test that reproduces it
                                              -> implement the fix, verify test passes
/code-review                                  -> code-reviewer: catch regressions

Preparing for production:

/security-scan                                -> security-reviewer: OWASP Top 10 audit
e2e-testing skill                             -> e2e-runner: critical user flow tests
/test-coverage                                -> verify 80%+ coverage

What's New: ECC 2.1

[!IMPORTANT] NEW IN ECC 2.1: Plan Canvas · Kimi harness · self-hosted compute on Itô GPUs. See the full release notes →

Plan Canvas: review plans by pointing, not retyping

…view the full README on GitHub.

// faq

What is ECC-Antigravity?

🚀 Everything Claude Code (ECC) for Google Antigravity. Full runtime compatibility: 68+ specialized agents, 280+ skills, and automated safety/quality lifecycle hooks powered by Gemini 3.8.. It is open-source on GitHub.

Is ECC-Antigravity free to use?

ECC-Antigravity is open-source under the MIT license, so it is free to use.

What category does ECC-Antigravity belong to?

ECC-Antigravity is listed under devtools in the Claudeers registry of Claude-compatible tools.

19 views
★ 13 stars
unclaimed
updated about 1 month ago

// embed badge

ECC-Antigravity on Claudeers
[![Claudeers](https://claudeers.com/api/badge/ecc-antigravity.svg)](https://claudeers.com/ecc-antigravity)

// retro hit counter

ECC-Antigravity hit counter
[![Hits](https://claudeers.com/api/counter/ecc-antigravity.svg)](https://claudeers.com/ecc-antigravity)

// reviews

// guestbook

0/500

// related in Developer Tools

🔓

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Curs…

// devtoolsaffaan-m/⟨JavaScript⟩★ 307,864◷ MIT[ claude ]
🔓

Makes your AI agent think like the laziest senior dev in the room. The best code is the code you never wrote.

// devtoolsDietrichGebert/⟨JavaScript⟩★ 187,728◷ MIT[ claude ]
🔓

AI coding assistant skill (Claude Code, Codex, OpenCode, Cursor, Gemini CLI, and more). Turn any folder of code, SQL schemas, R scripts, shell scripts, docs,…

// devtoolssafishamsi/⟨Python⟩★ 147,800◷ MIT[ claude ]
🔓

Use Garry Tan's exact Claude Code setup: 23 opinionated tools that serve as CEO, Designer, Eng Manager, Release Manager, Doc Engineer, and QA

// devtoolsgarrytan/⟨TypeScript⟩★ 140,465◷ MIT[ claude ]
→ see how ECC-Antigravity connects across the ecosystem