Set Up ECC in Google Antigravity IDE

Install and configure ECC's agent harness in Google Antigravity IDE.

Introduction

30 Second Summary

AI coding agents can write code fast, but without guardrails they skip tests, ignore security, and produce inconsistent output. Giving them structured workflows and coding standards turns raw speed into reliable engineering.

In this project, you will install and configure ECC (Enhanced Coding Conventions) inside Google Antigravity IDE, giving its agents a complete methodology for planning, building, reviewing, and verifying code.

What You'll Build

A fully configured ECC-powered Antigravity IDE workspace with agent orchestration for implementation planning, test-driven development, automated code review, security scanning, and quality gates.

By the end of this project, you'll have:

A working .agent/ directory with ECC rules, workflows, and skills installed for all supported languages.
A verified, healthy ECC installation confirmed by the doctor script.
Hands-on experience with the 5 core ECC workflows (plan, TDD, build-fix, code-review, quality-gate) inside Antigravity IDE.
Secret Mission: Set up ECC's continuous learning system so your workspace gets smarter with every coding session.

Are there any prerequisites?

None. This guide covers everything from cloning the repository to running your first workflows. You just need a Windows machine with Git, Node.js, and Google Antigravity IDE installed.

Clone and Install ECC for Antigravity

ECC is a framework that transforms Antigravity IDE's general-purpose agents into structured, methodology-driven assistants. Before you can use any workflows or skills, you need the ECC source code on your machine.

In this step, you'll clone the ECC repository, install its Node.js dependencies, and run the installer that maps ECC's components into Antigravity IDE's .agent/ directory format.

In this step, get ready to:

Clone the ECC repository and install dependencies.
Run the Antigravity installer with all language modules.
Verify the installation completed successfully.

Clone the ECC repository and install dependencies

You'll download the full ECC codebase from GitHub and install its package dependencies so the installer scripts can run.

Press the Windows key to open your search bar.
Type PowerShell and press Enter to open it.

Move to your Desktop by running this command:

cd ~/Desktop

Clone the ECC repository and install its dependencies by running these commands:

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

What do these commands do?

git clone downloads the entire ECC repository from GitHub to a new folder called ECC on your Desktop.
cd ECC moves you into that newly created project folder.
npm install downloads all the Node.js packages ECC depends on into a node_modules/ folder.

Confirm the setup succeeded by running:

ls

You should see node_modules listed in the output alongside other ECC files and folders like scripts, rules, and agents.

Not seeing node_modules?

Make sure you ran npm install from inside the ECC folder, not from your Desktop. Run pwd to check your current location.
If you see a permission error, try closing PowerShell and reopening it with Run as Administrator.
help me troubleshoot my git clone or npm install

Run the Antigravity installer with all language modules

The ECC installer transforms raw source files into the directory structure Antigravity IDE expects. It maps ECC's rules/ to .agent/rules/, commands/ to .agent/workflows/, and agents/ to .agent/skills/.

Run the Antigravity installer with all language modules by running this command:

.\install.ps1 --target antigravity typescript python golang swift php

What does this command do?

--target antigravity tells the installer to use Antigravity IDE's .agent/ directory format instead of formats for other editors.
The language names (typescript, python, golang, swift, php) tell ECC which language-specific coding standards to include in the rules.
The installer flattens all rule files into a single directory and converts commands and agents into Antigravity-compatible workflows and skills.

Alternative installation method

If the PowerShell script has issues, you can use the cross-platform installer instead:

npx ecc-install --target antigravity typescript python golang swift php

Confirm the .agent/ directory was created by running:

ls .agent

You should see rules, workflows, and skills directories listed in the output.

Don't see the .agent/ directory?

Make sure you're running the command from inside the ECC folder. Run pwd to check your current location.
If you see a "script not recognized" error, try the npx ecc-install alternative shown in the tip above.
help me fix the ECC Antigravity installer

Verify the install completed

ECC includes a verification command that confirms all components were installed correctly for your target IDE.

Check the installed components by running this command:

node scripts/ecc.js list-installed

What should I see?

The output confirms that rules, workflows, and skills were installed for the antigravity target. It also lists the specific language modules (TypeScript, Python, Go, Swift, PHP) that are active.

ECC v2.0.0 includes 262 skills, 64 agents, and 84 workflows across all supported languages.

Confirm the install state file exists by running:

ls .agent/ecc-install-state.json

You should see the file path printed without any error. This file tracks everything ECC installed, enabling safe updates and uninstalls later.

Getting a file not found error?

Run ls .agent to check if the .agent/ directory exists at all. If not, go back to the previous substep and re-run the installer.
If the directory exists but the state file is missing, try running the installer again. It may have been interrupted partway through.
help me fix my ECC installation verification

Your ECC installation is ready. Next up, you'll explore the .agent/ directory structure in detail and open the project in Antigravity IDE.

Verify and Explore the Installation

Your ECC installation is complete. You have a .agent/ directory packed with rules, workflows, and skills ready to guide Antigravity's agents.

Before you start using these tools, you need to understand what was installed and confirm everything is healthy. In this step, you will explore the directory structure, open the project in Google Antigravity IDE, and run a diagnostic check.

In this step, get ready to:

Explore the .agent/ directory and understand how ECC maps its components.
Open the ECC project in Antigravity IDE and confirm it detects your configuration.
Run the ECC doctor script to verify a healthy installation.

Understand the .agent/ directory structure

ECC transforms its source directories into a layout that Antigravity IDE understands. Knowing which source maps to which destination helps you troubleshoot and customize later.

Switch back to your PowerShell window where you are inside the ECC directory.
Explore the directory tree that the installer created by running:

Get-ChildItem .agent -Recurse -Name | Select-Object -First 20

You should see files organized under three subdirectories: rules/, workflows/, and skills/.

Here is the overall layout:

.agent/
├── rules/              <- Coding standards (flattened from common + all languages)
│   ├── coding-standards.md
│   ├── testing.md
│   ├── security.md
│   ├── typescript.md
│   ├── python.md
│   ├── golang.md
│   └── ...
├── workflows/          <- ECC commands mapped to Antigravity workflows
│   ├── plan.md
│   ├── code-review.md
│   ├── build-fix.md
│   ├── quality-gate.md
│   └── ...
├── skills/             <- Agent definitions mapped to Antigravity skills
│   ├── planner.md
│   ├── code-reviewer.md
│   ├── tdd-guide.md
│   ├── security-reviewer.md
│   └── ...
└── ecc-install-state.json

How does ECC map to Antigravity?

ECC's repository has three core source directories. The installer transforms them into Antigravity's expected .agent/ layout:

ECC rules/ (common + language-specific) gets flattened into .agent/rules/. Antigravity reads these as workspace rules that guide agent behavior.
ECC commands/ becomes .agent/workflows/. You invoke these in the agent using slash commands like /plan or /code-review.
ECC agents/ becomes .agent/skills/. These are skill definitions that the agent picks up automatically when a conversation starts.

Open the project in Antigravity IDE

Antigravity IDE automatically detects the .agent/ directory when you open a project folder. Once detected, the agent can access all your ECC rules, workflows, and skills.

Press the Windows key to open your search bar.
Type Antigravity and press Enter to launch Google Antigravity IDE.
Click File in the top menu bar.
Click Open Folder.
Navigate to the ECC folder you cloned earlier and click Select Folder.

Antigravity loads the project. The Agent Side Panel on the right side of the editor is where you interact with the agent.

Open the Agent Side Panel by clicking the agent icon on the right side of the editor (or start a new conversation).
Start a conversation. The agent automatically sees all available ECC skills by name and description.
Click the ... dropdown at the top of the agent panel to open Customizations.
Navigate to the Rules panel. You should see your workspace rules from .agent/rules/ listed.
Navigate to the Workflows panel. You should see your ECC workflows available.

What should I see?

In the Customizations panel, your workspace rules from .agent/rules/ should be listed. Workflows from .agent/workflows/ appear as invocable slash commands.

When you start a conversation, the agent sees all skill names and descriptions from .agent/skills/. If a skill is relevant to your task, the agent reads its full instructions and follows them automatically.

Don't see your rules or workflows?

Make sure you opened the ECC folder itself (the one containing .agent/), not a parent folder. Antigravity only detects .agent/ at the workspace root.

If you still don't see them, close and reopen the folder. Antigravity scans for the .agent/ directory on folder open.

Help me troubleshoot why Antigravity IDE isn't detecting my .agent/ directory with ECC rules and workflows.

Run the ECC doctor

ECC includes a diagnostic script that checks for missing files, broken references, and configuration issues. Running it now confirms your installation is complete and healthy.

Open the integrated terminal inside Antigravity IDE by pressing Ctrl+` (backtick key).
Run the ECC doctor by entering this command:

node scripts/ecc.js doctor

What does this command do?

The doctor subcommand scans your .agent/ directory and cross-references it against ecc-install-state.json. It flags missing files, broken references between skills and workflows, and any configuration issues that could cause agents to misbehave.

You should see output confirming all components are healthy with no critical issues reported.

If the doctor reports issues

If you see warnings or errors, run the repair command to fix them automatically:

node scripts/ecc.js repair --target antigravity

This rebuilds any missing or corrupted files in .agent/ without touching files you may have customized.

Seeing 'node' is not recognized?

This means Node.js is not in your system PATH. Close and reopen Antigravity IDE's terminal. If that doesn't fix it, open a new PowerShell window outside the IDE and run the doctor command from the ECC directory instead.

Help me fix the 'node is not recognized' error when running ECC doctor in Antigravity IDE's terminal.

Your ECC installation is verified and Antigravity IDE is loaded with all 262 skills, 64 agents, and 84 workflows at its disposal. Next up, you will put these workflows to work on real tasks.

Master the 5 Core Workflows

Your ECC installation is healthy and Antigravity IDE recognizes all the skills, rules, and workflows. Now it's time to put them to work.

ECC organizes your development process into a clear loop: plan before you code, enforce TDD while you code, and review after you code. In this step, you'll practice the 5 workflows that make up this loop so you know exactly which one to reach for at each stage.

In this step, get ready to:

Use /plan to decompose a task into implementation phases before writing any code.
Practice the TDD workflow and /build-fix to write tested code and recover from build failures.
Run /code-review and /quality-gate as your post-coding verification checks.

/plan - implementation planning

Every well-built feature starts with a plan. The /plan workflow delegates to ECC's planner agent, which decomposes a task description into structured phases: analysis, interface design, implementation steps, testing strategy, and verification criteria.

In the Agent Panel on the right side of Antigravity IDE, invoke the plan workflow.
When prompted for a task description, enter: Add a logging system that tracks agent decisions and outputs to a structured JSON file.
Wait for the planner agent to produce its output.

The agent breaks your task into distinct phases. You should see sections covering analysis, interface design, implementation steps, a testing strategy, and verification criteria.

When do I use /plan?

Use /plan before writing any code. It gives the agent a roadmap so subsequent coding steps are focused and well-structured.

Without a plan, agents tend to jump straight into implementation and miss edge cases. The plan workflow prevents this by forcing decomposition first.

TDD workflow and /build-fix

The TDD workflow enforces a strict cycle: define interfaces first, write failing tests (RED), implement minimal code (GREEN), then refactor (IMPROVE). It targets 80%+ test coverage and prevents the agent from skipping tests or writing untested code.

In the Agent Panel, ask the agent: Write a utility function that validates JSON schema using TDD.
Watch the agent follow the TDD cycle. It defines the interface, writes a failing test, implements the function to make the test pass, then refactors.

What is the RED/GREEN/IMPROVE cycle?

RED means writing a test that fails because the code doesn't exist yet.
GREEN means writing the minimum code needed to make the test pass.
IMPROVE means refactoring for clarity and performance while keeping the test green.

If the build breaks at any point during TDD, the /build-fix workflow is your recovery tool.

Invoke the build-fix workflow from the Agent Panel.
The build-error-resolver agent diagnoses the failure and applies fixes systematically.
Confirm the build passes after the fix is applied.

TDD prevents untested code

Without the TDD workflow, agents often produce code that looks correct but has no tests. The TDD skill forces the agent to prove correctness with tests first, so you never end up with untested logic.

/code-review and /quality-gate

Once the agent has produced code, it's time for verification. These two workflows are your post-coding checks.

In the Agent Panel, invoke the code-review workflow on the code the agent just produced.
Review the feedback. The code-reviewer agent checks quality, security, maintainability, naming, and test coverage.
Address any issues the code-reviewer flags before proceeding.

After addressing review feedback, run the final comprehensive check.

Invoke the quality-gate workflow from the Agent Panel.
This runs a comprehensive verification: build, test, lint, typecheck, and security scan.
Confirm all checks pass. If any fail, the agent reports exactly what needs fixing.

The full workflow loop

Think of ECC's workflows as a timeline:

/plan runs before you write code. It creates the roadmap.
TDD + /build-fix run during coding. They enforce testing and recover from failures.
/code-review + /quality-gate run after coding. They verify everything meets standards.

Workflow not appearing in the Agent Panel?

Make sure the .agent/workflows/ directory contains the corresponding .md file (e.g. plan.md, code-review.md). If files are missing, run the repair command from the previous step.

help me troubleshoot why ECC workflows are not showing in the Antigravity Agent Panel

You now have hands-on experience with all 5 core ECC workflows. Next up, you'll put the full loop to work on a real component of your AI agent project.

Use ECC on Your Agent Project

You now have all five core ECC workflows under your belt. You know when to reach for each one: /plan before writing code, TDD during implementation, and /code-review plus /quality-gate after.

Now it's time to put the full loop to work on something real. In this step, you will plan, build, review, and verify a component of your own AI agent project using ECC's workflow system inside Antigravity IDE.

In this step, get ready to:

Plan an AI agent component using the /plan workflow.
Build the component with ECC-enforced TDD patterns.
Review and verify the output passes the quality gate.

Plan a component of your AI agent

Every production-quality feature starts with a plan. The /plan workflow gives Antigravity's agents a structured roadmap before they write a single line of code.

Think of one specific component of your AI agent project. Good candidates include a prompt routing system, a memory persistence layer, or an API gateway.
In Antigravity IDE's Agent Panel, invoke the /plan workflow.
Enter a description of your component. For example: Add a logging system that tracks agent decisions and outputs to a structured JSON file.

The planner agent decomposes your task into phases: analysis, interface design, implementation steps, testing strategy, and verification criteria.

Review the implementation plan the agent produces.
Refine it by giving feedback on the artifacts. For example, ask the agent to add error handling to a specific phase or adjust the testing strategy.

Why plan before building?

Without a plan, agents tend to jump straight into code and miss edge cases. The /plan workflow forces a structured decomposition that catches design issues before implementation begins.

Think of it as the difference between sketching a blueprint and building a house room by room with no layout.

Pick something small and testable

Choose a component you can verify in one session. A single utility module or a data validation layer works better than an entire API service for your first ECC-guided build.

Execute with ECC guiding the agents

With your plan in place, it's time to let Antigravity's agents execute. ECC's rules automatically enforce quality standards on every file the agents produce.

Let the agents begin executing your implementation plan. ECC's rules from .agent/rules/ automatically enforce coding standards, security checks, and test requirements on every file modification.
Watch for the TDD pattern in action. The agents should define interfaces first, write failing tests (RED), implement minimal code (GREEN), then refactor (IMPROVE).
If the build breaks at any point, invoke /build-fix to let the build-error-resolver agent diagnose and fix the failure.

What is ECC enforcing behind the scenes?

While agents write code, ECC's rules silently enforce coding standards from coding-standards.md, security requirements from security.md, and testing practices from testing.md.

The target is 80%+ test coverage. If agents try to skip tests or write untested code, the TDD workflow skill prevents it.

If your component has UI elements, use Antigravity's built-in browser to verify them visually.
Let the agents complete execution. You should have working code with tests before moving to the review phase.

Agents not following TDD?

Make sure the tdd-guide.md skill file exists in .agent/skills/. If it's missing, run node scripts/ecc.js repair --target antigravity to restore it.

You can also explicitly remind the agent to follow TDD by referencing the workflow in your prompt.

Why aren't my agents following the TDD pattern when building my component?

Review and gate the output

The final phase of the ECC workflow loop is verification. This ensures the code meets production standards before you consider it done.

Invoke /code-review on the code the agents produced.
The code-reviewer agent checks quality, security, maintainability, naming conventions, and test coverage.
Address any issues the code-reviewer flags. Ask the agents to fix specific problems or make the changes yourself.

What does /code-review check?

The code-reviewer agent evaluates five dimensions: code quality, security vulnerabilities, maintainability, naming consistency, and test coverage.

It uses the rules in .agent/rules/ as its standards. Any violation of your installed language rules gets flagged.

Once all review issues are resolved, invoke /quality-gate as the final verification.
The quality gate runs a comprehensive check: build, test, lint, typecheck, and security scan.
If everything passes, you have a production-quality component built with full ECC enforcement.

Quality gate failing?

Check the specific failure reason in the output. Common causes include test coverage below 80%, linting errors, or unresolved security findings from the code review phase.

Run /code-review again after fixing issues, then re-run /quality-gate. The loop is iterative.

My quality gate is failing after code review. How do I diagnose and fix the specific issues?

You have now completed the full ECC workflow loop on a real component: plan, build with TDD, review, and quality gate.

Secret mission

Set Up Continuous Learning

ECC can do more than enforce standards. It can learn from your coding sessions and evolve its own skills over time. In this mission, you will configure ECC's continuous learning system so your workspace gets smarter every time you code.

Clean Up Your Resources

Decide whether to keep your resources running, pause them to come back later, or delete them entirely. This project runs entirely locally, so there are no ongoing costs.

Resources you used:

ECC repository (the ECC directory containing node_modules/, .agent/, scripts, and configuration files).
Session data and learned instincts (local files stored under the default agent data home).

Keep everything running

No action needed. Choose this if you plan to keep using ECC in your projects.

ECC stays active in every project you open in Antigravity IDE that contains a .agent/ directory.
To use ECC in a new project, copy the .agent/ directory to that project folder, or run the installer again from within it.
Learned instincts continue to accumulate as you code, making ECC smarter over time.

Pause - I'll come back to this later

There are no running processes or cloud resources to stop. ECC is entirely file-based, so it sits idle until you invoke a workflow.

Close the ECC project folder in Antigravity IDE.
The .agent/ directory and all session data remain on disk, ready for when you return.
Your learned instincts persist locally. Pending instincts expire after 30 days by default, but evolved instincts remain indefinitely.

Delete - I don't want to use this again

Remove all ECC files and start fresh. This is permanent.

Close the ECC project in Antigravity IDE.
Open PowerShell and navigate to the ECC directory.
Run the official uninstall script to remove all ECC-managed files:

node scripts/uninstall.js --target antigravity

Navigate up one directory, then remove the entire ECC repository folder:

cd ..
Remove-Item -Recurse -Force ECC

Session data and learned instincts are stored separately under the default agent data home. If you set the ECC_AGENT_DATA_HOME environment variable, delete that directory as well. If you used the default location, check for any remaining ECC session files and remove them.

Nice Work!

You did it. You now have a fully configured ECC-powered development environment inside Google Antigravity IDE, complete with structured workflows, coding standards enforcement, and agent orchestration.

You've learned how to:

Installed ECC v2.0.0 with full language support (TypeScript, Python, Go, Swift, PHP) targeting Google Antigravity IDE, creating a production-ready .agent/ directory with rules, workflows, and skills.
Practiced the 5 core ECC workflows (plan, TDD, build-fix, code-review, quality-gate) and understood when to reach for each one in a real development session.
Used the full ECC workflow loop to plan, build with TDD, review, and verify a real component of your AI agent project inside Antigravity IDE.
(Secret Mission) Configured continuous learning v2 so ECC extracts patterns from your coding sessions and evolves them into custom skills tailored to your workflow.

Ready to quiz yourself?