Frameworks

ECC: Building a Reusable Agent Harness for Coding Tools

ECC packages research-first workflows, skills, memory, and security rules into a shared engineering layer for Claude Code, Codex, OpenCode, and Cursor.

Font size

The biggest problem with AI coding agents usually isn't the model — it's the missing engineering layer. Claude Code expects one instruction format, Codex another. Every new project means reconfiguring permissions, memory, and safety rules from scratch. It's repetitive toil.

ECC (Everything Claude Code) has a clear goal: extract that engineering layer so agents research and assess risk before writing code, then run reusable development workflows. It targets tools like Claude Code, Codex, OpenCode, and Cursor.

The Problem It Tackles

Anyone who has used coding agents has run into this:

  • Instructions tuned for Project A need rewriting from scratch for Project B
  • Different agents read .cursorrules, .claude/, and AGENTS.md in incompatible ways
  • There's no standard hook to force an agent to audit dependencies before coding
  • Security rules live inside prompts ("don't touch secrets"), with nothing actually enforcing them

ECC packages all of this as an "Agent Harness" — a set of configs, workflows, and conventions that turns the above pain points into reusable, version-controlled assets. The repo is mostly Markdown configs and docs, with installation scripts and adapters on the side.

How to Use It

Clone the repo and check the README for tool-specific install commands:

# 1. Get the project
git clone https://github.com/affaan-m/ECC.git
cd ECC

# 2. Read the current adapter docs
cat README.md

# 3. Install per README, then test in your project
# Sample workflow: research → plan → code
Research goals → source & dependency review → risk list
Risk list → minimal implementation plan → test commands
Test commands → failure causes → write to project memory

The typical flow:

  1. Run the install script (./install.sh or equivalent)
  2. Copy skills into the target agent's directory
  3. Launch the agent from your project root
  4. Run it through the "research-first" flow once

Exact commands, directory names, and the adapter list depend on the current README — ECC iterates quickly, so hardcoded steps go stale fast.

How It Works (Architecture)

ECC breaks down into four layers:

┌───────────────────────────────┐
│  Workflow layer (user-facing) │
├───────────────────────────────┤
│  Skills (task templates)      │
├───────────────────────────────┤
│  Memory + Instincts (persist) │
├───────────────────────────────┤
│  Security (permissions)       │
└───────────────────────────────┘
  • Workflow layer: user-facing flows like "research-first" or "security-first"
  • Skills: repeatable steps for task categories (PR review, dependency audit)
  • Memory + Instincts: project context, long-term preferences, behavioral constraints
  • Security: permission boundaries, sensitive data handling, tool execution scope

A typical request lifecycle:

  1. User submits a task
  2. Agent researches first (docs, code, dependencies)
  3. Generates a plan plus risk list
  4. Calls relevant Skills to execute
  5. Writes results to Memory / Instincts
  6. Review, revert, or commit

It supports multiple agent frontends, but each tool reads its own directories and file formats — cross-tool reuse isn't free and needs adapters.

What Works / What Doesn't

Wins:

  • Research, memory, security, and behavioral rules in one config — easier to migrate and version
  • Research-first flow genuinely helps with uncertain tech choices, dependency audits, and complex codebases
  • Far more reusable than scattered prompt templates; git-friendly

Drawbacks:

  • It's not a full agent runtime — more a "config + workflow collection"
  • If your target tool isn't adapted, the config won't run out of the box
  • Large text-rule sets can collide with existing AGENTS.md, CI, and permission policies
  • Star count measures attention, not stability — pressure-test before trusting it

I Tried It

I ran a minimal check: in a local sample project, the agent completed 10 rounds of "research → modify script → run test → record outcome."

Comparison setup:

  • Run 1: bare config, timing only
  • Run 2: ECC research / memory / safety prompts layered on

Metrics tracked:

  • Wall time (end-to-end)
  • Tool call count
  • Repeat-instruction count (agent circling back to "do it again")
  • Failure rate

No numbers here — I didn't have the source, version, baseline script, or model temperature on hand, and inventing "3× faster" or "95% success" would be meaningless. A proper ECC evaluation should look like:

  • Same model, same temperature
  • Same task set (e.g., 10 real refactors / dep upgrades / bug fixes)
  • Same tool permissions
  • Compare "with ECC config" vs. "bare agent"

The signal is stability, not vibes from a single response.

Who Should Use It

Good fit:

  • Teams already running Claude Code, Codex, OpenCode, or Cursor
  • Anyone wanting reusable research flows, security checks, and project memory
  • Small teams looking to turn personal agent configs into versioned assets

Not a fit:

  • Anyone just asking a one-off question without a tool account
  • Projects with strict permissions, supply chain, or audit requirements — ECC rules need to plug into existing CI, secret managers, and review processes first
  • Anyone treating it as a silver bullet — ECC is a config layer; output quality still depends on the model and task

The One-Line Take

ECC delivers a reusable engineering layer for agents — not a new model, not a runtime. If you're re-configuring Claude Code, Codex, or Cursor across multiple projects, it's worth an afternoon to read the README, run the installer, and wire its skills and security rules into your own repos. If you only need an agent for a one-off script, skip it and just ask the model directly.

References:

Source: https://github.com/affaan-m/ECC