Can I use Kodelyth ECC with Aider?

Yes. Run `kodelythecc --target aider` in your project. ECC writes 71 agents, 196 skills, and 104 commands into `.aider-ecc/` + `CONVENTIONS.md`. Aider reads `CONVENTIONS.md` on every session.

Does ECC replace Aider's agent loop?

No. Aider owns the pair-programming loop (edit/commit/review cycle with git). ECC adds specialist agents routable by intent, token compression, local memory, and MCP — at different layers of the stack.

What does ECC add over plain Aider?

71 specialist agents selectable by plain-language intent routing; parallel multi-agent commands like /team-review and /devil-mode; a universal MCP server; RTK input compression (60-90%); Terse output compression (40-70%); a codebase AST graph across 158 languages; and local Memory Core recall that survives a repo move.

Does Aider auto-wire the ECC MCP server?

Not automatically — Aider does not have a standard MCP client built in. ECC's catalog reaches Aider through the markdown convention file; the MCP server is available separately for other MCP-capable tools.

Does ECC respect Aider's one-prompt-at-a-time style?

Yes. ECC's agents live in the convention file as patterns Aider can invoke when your prompt matches — they don't replace Aider's interactive loop. Nothing changes about how you talk to Aider.

By Kodelyth · updated November 11, 2026 · v2.30.0

Kodelyth ECC vs Aider

Short version. Aider is an open-source terminal AI pair-programmer that owns the edit-commit-review loop and knows git deeply. Kodelyth ECC is a toolkit that augments pair-programmers (Aider included) with 71 specialist agents, token compression layers, memory, and a universal MCP server. They sit at different layers and stack cleanly.

What Aider is

Aider is a Python CLI that acts as a pair-programmer in your terminal. It:

Talks to Claude, GPT, local models (and many more) via its own adapter layer
Reads your git repo and understands which files are in scope
Applies edits, writes commits with generated messages, and manages a working-copy diff in-conversation
Supports a CONVENTIONS.md file at the root, which it loads into every session as persistent instructions

Aider's superpower is the git-aware edit loop. If you want an AI that lives alongside your editor and rewrites files for you with commits that pass your hooks, Aider is a very strong choice.

What ECC is

ECC is not a pair-programmer. It's a toolkit of agents, skills, commands, rules, and infrastructure that sits inside a pair-programmer or agent harness — Claude Code, Cursor, Windsurf, Aider, and 8 more — to give it:

71 specialist agents — debug-detective, code-reviewer, security-reviewer, performance-optimizer, 67 more — selected by plain-language intent routing.
104 slash commands including 8 parallel multi-agent ones like /team-review (4 reviewers in parallel), /devil-mode (adversarial sweep), /debug-blitz (3 debuggers for persistent bugs).
Universal MCP server — bridges the catalog to any MCP client.
RTK + Terse — input and output token compression, 55-65% combined.
Codebase graph across 158 languages — structural queries at ~1% the cost of file-by-file grep.
Memory Core — local, git-remote-identified, fused relevance × recency × outcome ranking.
Super Agent — autonomous orchestrator for objectives too big for one pass.

How they stack

Layer	Aider	ECC
Interactive pair-programmer with git-aware edits	✓	—
Multi-model adapter layer	✓	—
CONVENTIONS.md for persistent project rules	✓	—
Automatic commit messages + diff review	✓	—
Specialist agents (71), routable by intent	—	✓
Catalog of skills, slash commands, parallel-fire commands	—	✓
Universal MCP server exposing the catalog	—	✓
Local memory that recalls past fixes	—	✓
Shell-output token compression (RTK)	—	✓
AI-reply token compression (Terse)	—	✓
Codebase AST graph (158 languages)	—	✓

The design bet: these are almost non-overlapping. Aider owns the git-aware pair-programming loop; ECC owns the specialists, token economics, memory, and MCP bridge around it.

How to install ECC into Aider

npm i -g kodelyth-ecc
# From the root of your Aider project:
kodelythecc --target aider

That writes ECC's agents, skills, and commands into .aider-ecc/, and appends the catalog pointer to your CONVENTIONS.md (or creates one). Aider loads CONVENTIONS.md on every session, so the ECC catalog is available immediately.

What auto-wires: the rules, agents, and commands as markdown context Aider reads on every turn.

What doesn't: the MCP server (Aider doesn't have an MCP client built in) and RTK's PreToolUse hook (Aider doesn't expose a hook API). You can still run the MCP server on its own for other tools that speak MCP, and RTK works as a shell-level alias wrapper outside Aider.

The honest tradeoffs

Stay on plain Aider when:

You love the git-aware pair-programming loop and don't want other abstractions on top.
CONVENTIONS.md and a short list of one-off prompts cover everything you need.
You're not paying enough in tokens to notice.

Add ECC when:

You keep writing variants of the same prompt ("review this for security, performance, and a11y") — /team-review fires 4 specialists in parallel.
You've noticed a token bill high enough to want a compression layer. RTK alone cuts shell-output tokens 60-90% per command.
You want the same specialists available in Claude Code or Cursor tomorrow — ECC installs into all of them with the same catalog.
You want sessions to compound. Memory Core recalls past solutions on every new prompt so you don't re-solve the same bug in the next session.

Bottom line

Aider is an excellent pair-programmer. ECC is the content and infrastructure layer that makes whichever pair-programmer you use more capable, cheaper, and portable. If Aider is your pair-programmer, install ECC into it:

npm i -g kodelyth-ecc && kodelythecc --target aider

Then open Aider in the same project. The ECC catalog is live on your very next prompt.

Last updated: 2026-11-11T00:00:00.000Z · v2.30.0