Can I use Kodelyth ECC with Cline?

Yes. Run `kodelythecc --target cline` inside a Cline project. It writes ECC's agents, skills, and rules to `.clinerules/` — Cline auto-loads that directory on every session.

Does ECC replace Cline?

No. Cline is the agent harness (the loop that reads your prompts, calls tools, and generates responses). ECC is the content layer around it — specialist agents, routing rules, memory, token savings. They operate at different levels of the stack.

Does Cline get the ECC MCP server auto-wired?

Not automatically — Cline stores its MCP settings inside VS Code's `globalStorage`, a version-specific path ECC refuses to guess. For Cline, you paste the ECC MCP server entry manually one time. See /docs/mcp for the entry. Six other IDEs (Claude Code, Cursor, Windsurf, Gemini CLI, Codex, Kiro) auto-wire.

Does RTK work in Cline?

RTK's compression works at the shell layer, so it applies to Cline commands too — but ECC does not currently auto-wire RTK's PreToolUse hook into Cline's config. You can install RTK with `kodelythecc rtk install` and wire it in manually for Cline.

If I only use Cline, do I need ECC?

Only if any of these are true: you want 71 specialist agents selectable by plain-language intent; you want local memory that recalls past fixes; you want 55-65% token savings across input + output; or you want the same agents available in another AI tool later. Cline alone is a competent agent harness — ECC makes it better, not replaceable.

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

Kodelyth ECC vs Cline

Short version. Cline is an AI agent harness — a VS Code extension that runs an agent loop against Claude/GPT/local models, with its own tool dispatcher. Kodelyth ECC is an AI coding toolkit that augments agent harnesses (Cline included) with specialist agents, routing, memory, token savings, and MCP. They operate at different layers, not against each other.

What Cline is

Cline is an open-source VS Code extension that implements the agent loop itself. It:

Reads your prompt
Plans tool calls (file reads, shell commands, edits)
Executes them
Feeds the results back to the model
Repeats until the task is done

It supports multiple model providers, keeps a human-in-the-loop approval mode, and reads .clinerules/ for persistent rules. It is a complete agent system by itself.

What ECC is

ECC is not an agent harness. ECC is a toolkit of agents, skills, commands, rules, and infrastructure that lives inside someone else's agent harness — Claude Code, Cursor, Windsurf, Cline, and 8 more. What it adds:

71 specialist agents — debug-detective, code-reviewer, security-reviewer, performance-optimizer, and 67 more, selected by plain-language intent routing.
196 skills — granular workflows the agent dispatches when a task matches.
104 slash commands — one-liners like /team-review, /devil-mode, /debug-blitz that fire multiple specialists in parallel.
Universal MCP server — bridges the catalog to any MCP client.
RTK + Terse — input and output token compression, 55-65% combined on typical sessions.
Codebase graph across 158 languages — structural queries at ~1% the cost of file-by-file grep.
Memory Core — local, git-remote-identified, redacts secrets, fuses relevance × recency × outcome.
Super Agent — autonomous orchestrator for objectives too big for one pass.

How they stack

Layer	Cline	ECC
The agent loop itself (plan → tool → observe → repeat)	✓	—
Model provider abstraction	✓	—
Human-in-the-loop approval mode	✓	—
Always-on project rules	✓ `.clinerules/`	—
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 point of the table: these are almost non-overlapping. Cline owns the loop; ECC owns the content and infrastructure around it.

How to install ECC into Cline

npm i -g kodelyth-ecc
# From your project root:
kodelythecc --target cline

That writes ECC's agents, skills, commands, and rules to .clinerules/ in your project. Cline loads that directory on every session.

What auto-wires: the rules, agents, skills, and commands as markdown context Cline can read.

What doesn't: the MCP server and RTK. Cline stores its MCP settings in VS Code's globalStorage (editor-version-specific path), and we won't guess a path that could silently corrupt your config. Manual MCP wiring takes 30 seconds — paste the server entry from /docs/mcp into Cline's MCP settings.

Six other IDEs (Claude Code, Cursor, Windsurf, Gemini CLI, Codex, Kiro) auto- wire MCP in one command. For Cline and Roo Code, it stays a one-time manual step.

The honest tradeoffs

Cline is sufficient alone when:

You want the simplest possible setup — one VS Code extension, done.
You don't yet have a token bill high enough to justify compression layers.
You're not working across multiple AI tools.
.clinerules/ and manual prompts cover everything you need.

Add ECC when:

You notice you keep writing the same instructions ("review this for X, Y, Z") — ECC's /team-review does it in parallel across 4 specialists.
You're paying more than you expected for a Cline-heavy workflow — RTK alone cuts input 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.

Bottom line

Cline is one of several agent harnesses. ECC is the content layer that makes whichever harness you use more capable, cheaper, and portable. If Cline is your harness, install ECC into it:

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

Then paste the ECC MCP server entry into Cline's MCP settings. One-time step, then everything is live.

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