ECC: A Unified AI Programming Operating System for Claude Code, Codex, and Cursor

Why Do We Need an "Operating System" for AI Programming?

If you've been juggling multiple AI programming tools recently, you've probably felt this firsthand: models keep getting more powerful, but what truly determines your productivity ceiling often isn't the model itself — it's the workflow behind it, the memory mechanisms, permission boundaries, reusable skills, and cross-tool consistency.

Claude Code has its own Hook and agent style, Cursor has its own integration approach, Codex suffers from insufficient Hook capabilities, and GitHub Copilot lacks even a Hook System and SubAgent API. Here, a Hook System refers to an event interception mechanism in AI programming tools that allows developers to insert custom logic at critical points like code generation, file writing, and command execution — similar to Git's pre-commit hooks. A SubAgent API is an interface that allows a primary Agent to dynamically dispatch sub-Agents to execute subtasks, serving as the core capability for building multi-Agent collaboration systems. Without these two capabilities, GitHub Copilot essentially remains a "code completion tool" rather than an orchestratable autonomous agent. The current AI programming ecosystem is highly fragmented — vendors go their own way on Hook mechanisms, context window management, and tool-calling protocols, forcing developers to reinvent a set of standards for each tool.

The project we're introducing today — ECC (Enhanced Claude Code) — was built to solve exactly this problem. It's a highly popular Agent Harness performance optimization system on GitHub. An Agent Harness is a framework pattern that unifies the execution environment, tool calling, context management, and security boundaries of AI agents into a standardized "runtime foundation," enabling AI agents to execute complex tasks in a controlled environment. ECC's goal isn't to be a point plugin — it's to unify Claude Code, Codex, OpenCode, Cursor, and other mainstream AI programming environments into a single operable, installable, extensible, and continuously evolving engineering system.

ECC Core Architecture: The Five-Layer Capability System Explained

ECC isn't about wrapping another layer of configuration — it's a complete Operator System. It takes capabilities that are typically scattered across prompts, scripts, and personal habits, and crystallizes them into a standardized structure with five distinct layers.

Skills System: 246 Reusable Capability Units

High-frequency development tasks are packaged into callable, suggestible capability units. Skills use a Skill.md plus YAML Front Matter format, designed to work across Claude Code, Codex, and OpenCode. The system has accumulated 246 skills covering real-world development scenarios like Patch Patterns, Documentation Lookup, and NextJS.

Instincts: Default Agent Behavior Patterns

Instincts make the Agent behave more like an engineering collaborator with default behavior patterns within workflows, rather than a passive tool waiting for instructions.

Memory and Session Infrastructure: Solving AI's Short-Memory Gap

Large language models are inherently stateless — each conversation starts from scratch, with no native ability to remember the previous session's context, decision history, or project state. This "short-memory gap" causes severe efficiency losses in long-cycle engineering tasks. ECC addresses this through state storage, structured recording, and query capabilities. V1.9.0 introduced SQLite State Store and Query CLI — SQLite requires no independent service process, supports SQL queries, and its files can be version-controlled with the project, making it ideal for embedding in development workflows. By persisting session state, installed component manifests, and Agent execution history to SQLite, ECC achieves cross-session "memory continuity," providing a solid foundation for session persistence.

Security and Guardrails: Five-Layer Protection Mechanism

In AI automation systems, an Observer mechanism is a meta-level monitoring layer responsible for watching Agent execution behavior and intervening when anomalous patterns are detected. ECC's five-layer protection design targets several categories of systemic risks common in autonomous AI agent execution: loop calling (Agents getting trapped in infinite retry loops), Memory Explosion (context windows filling with invalid information causing performance collapse), Sandbox escape (Agents accidentally accessing system resources beyond their authorization scope), and Re-entrancy issues (state races during concurrent execution). These problems rarely surface in single conversations but significantly impact system stability in long-running automation pipelines. ECC standardizes these protection mechanisms and builds them into the framework layer, so developers don't need to repeatedly implement safety logic in every project.

Research-First Development: Evidence-Driven Programming Workflow

This layer embeds the process of checking documentation first and making evidence-driven judgments into the AI programming workflow, rather than letting the model improvise freely.

Cross-Tool Compatibility: Treating Differences as Architecture Design Problems

ECC places special emphasis on Cross-Tool Feature Parity. Rather than avoiding platform differences, it treats them as architecture design problems to solve:

• agents.md is placed in the repository root as a cross-tool universal file, readable by Claude Code, Cursor, Codex, and OpenCode
• For GitHub Copilot, a separate github-copilot-instructions.md adaptation is provided
• Cursor reuses Claude Code's Hook scripts through a Dry Adapter Pattern, avoiding duplicate maintenance of the same capabilities. This pattern combines the DRY (Don't Repeat Yourself) principle with the Adapter pattern — "adapting" Claude Code's Hook scripts for Cursor's use, so when underlying capabilities change, only one modification is needed and all adaptation layers automatically benefit
• Skill formats are uniformly designed — write once, use everywhere

The message these designs convey is clear: ECC aims to be a universal AI programming operating system layer, not a theme skin for any single tool.

V1.9.0 Update: Selective Installation and Stability Breakthrough

V1.9.0 is a key milestone for ECC, introducing the Selective Install architecture.

The project implements this architecture through a Manifest Driven Install Pipeline — a declarative deployment pattern widely used in package managers like npm and Helm, and infrastructure-as-code tools like Terraform. Its core idea is to use structured manifests to describe the "desired state."