The scars are visible everywhere.

The God Object

The file src/core/task/index.ts is 3,756 lines. One class. It handles the agent loop, API requests, streaming, tool dispatch, context management, UI communication, hook execution, checkpoint management, browser sessions, environment detection, a todo list tracker, file caching, loop detection, and error recovery.

For context: Claude Code’s equivalent is 1,729 lines. Goose’s is 900. Cline’s is the largest single agent loop file across all 12 projects I’ve analyzed.

It gets worse. The ToolExecutor constructor takes 30+ parameters, 15 of which are callback functions with names like sayAndCreateMissingParamError and removeLastPartialMessageIfExistsWithType. This is constructor injection taken to its logical extreme

.Four layers: Extension → Controller → Task → ToolExecutor. The red zone in the diagram is the Task class — everything flows through it. The dashed red line shows the approval flow: when the agent needs permission, it polls a shared variable every 100ms until the user clicks a button in the webview.

// From src/core/task/index.ts
await pWaitFor(
() => this.taskState.askResponse !== undefined ||
this.taskState.lastMessageTs !== askTs,
{ interval: 100 },
)

Polling. Shared mutable state. No mutex on the read path. It works, but it’s the kind of architecture that makes you check the git blame.

YOLO Mode

One toggle. That’s all it takes to auto-approve every tool call, including execute_command. The agent can run arbitrary shell commands without asking. The auto-approve logic checks YOLO mode first, before any other permission check.

There is a CommandPermissionController that validates commands against allow/deny patterns — but it’s gated behind an environment variable that almost nobody will know to set.

40+ Providers (And Why That Matters)

The src/core/api/providers/ directory has 43 files. Anthropic, OpenRouter, Bedrock, Vertex, OpenAI, Gemini, Groq, DeepSeek, Ollama, xAI, Qwen, Doubao, Moonshot, and 30 more. Each one is a separate class with its own SDK, error handling, and streaming adaptation.

No other open-source coding agent comes close. Claude Code only supports Anthropic. Goose has 30+ through a unified registry. Cline’s approach is brute-force — but it works, and it’s a genuine competitive moat.

It also supports separate providers for planning vs. execution. You can think with Claude and code with DeepSeek. The configuration surface area is enormous — ApiConfiguration has 100+ fields — but the flexibility is real.

The Prompt Variant System

This is the part worth stealing. Cline doesn’t use one system prompt for all models. The PromptRegistry selects from 10+ variants: next-gen for Claude 4+, devstral for Mistral’s coding model, gemini-3, gpt-5, xs for small models, and a generic fallback.

Each variant defines a template with {{SECTION}} placeholders. Different models get different instruction structures because they respond differently. Most agents treat prompts as one-size-fits-all. Cline doesn’t.

Hooks: Shell Scripts as Extension Points

Eight lifecycle hooks: TaskStart, TaskResume, TaskCancel, UserPromptSubmit, PreToolUse, PostToolUse, PreCompact, Notification. Each one runs a shell script from .cline/hooks/.

The cancellable hooks can inject text into the conversation. A PreToolUse hook could run a linter before the agent edits a file. A UserPromptSubmit hook could query a database and add context.

The risk: hook scripts run with full VS Code permissions. Clone a repo with a malicious .cline/hooks/ directory and it executes code when you open the project. No sandboxing, no signature verification.

What Cline Gets Right

Provider diversity — 40+ backends, unmatched.

The hooks system — no other coding agent has lifecycle hooks with context injection.

Loop detection — a 70-line module that catches the model calling the same tool with identical arguments. Soft warning at 3, hard stop at 5. Simple and effective.

File read deduplication — tracks which files have been read and their modification times. If unchanged, the model gets an abbreviated version instead of burning tokens re-reading the same file.

Focus Chain — a markdown todo list the model maintains during execution. Users can edit it directly. No other agent in our survey has this.

What Cline Gets Wrong

The God Object — 3,756 lines of bidirectional coupling between Task, ToolExecutor, and Controller through callback chains.

Context management — truncation, not summarization. When the context window fills up, Cline deletes old messages. Claude Code has a 4-layer cascade from surgical deletion to structured archival. Cline jumps straight to “throw away a quarter of the conversation.”

No tool sandboxing — every tool runs in-process. A hung tool blocks the entire extension. Compare this to Goose (MCP process isolation) or Codex CLI (OS-level sandbox via seatbelt/landlock).

Recursive agent loop — recursivelyMakeClineRequests literally calls itself. Deep tool chains produce deep call stacks. Claude Code uses while(true). This matters.

The Verdict

Grade: B-

Cline is what happens when a weekend project gets 60K stars. The feature set is massive — probably the most capable open-source coding agent available. But the core is a 3,756-line God Object that needs to be split into an agent loop, a stream processor, a context manager, and a UI bridge.

Would I use it? Yes — the VS Code integration and provider diversity are unmatched. Would I bet on it long-term? That depends on whether the team stops adding features long enough to fix the foundation.

This is a condensed version. The full teardown — with architecture diagrams, code snippets, cross-project comparisons, and a verification log — is on GitHub:

Read the full teardown → awesome-ai-anatomy/cline at main · NeuZhou/awesome-ai-anatomy

AI Anatomy is a series of source-level teardowns of production AI systems. 12 projects dissected so far. Star the repo to get notified when the next one drops: GitHub - NeuZhou/awesome-ai-anatomy: Deep source code teardowns of 11 AI agent projects (Claude Code