Why Do Two Sonnet 4.5 CLI Tools Perform So Differently?

Recently I used Claude Code CLI and GitHub Copilot CLI and found that, although both rely on the Claude Sonnet 4.5 model, Claude Code feels noticeably smarter. This article records the technical reasons for the performance gap.

Core Issue

Same model does not guarantee same performance. Claude Sonnet 4.5 natively supports a 200K‑token context window and the Extended Thinking feature, but Copilot CLI imposes a middle‑layer that severely restricts these capabilities.

Copilot CLI’s Three Major Limitations

1. Context window severely shrinks

Claude Sonnet 4.5 native capability:

Standard: 200K tokens

Long‑context version: 1M tokens

Copilot CLI actual limitation:

≈ 8K tokens context window (user‑measured)

Officially undisclosed, but community tests converge on this value

Practical impact:

# Scenario: analyzing a codebase with 10 files
# Claude Code CLI (200K context)
# ✓ Can load multiple related files simultaneously
# ✓ Maintains full code‑relationship understanding
# ✓ Consistent analysis results

# Copilot CLI (8K context)
# ✗ Can only keep 1‑2 files
# ✗ Frequently forgets earlier analysis
# ✗ Requires repeated re‑reading

8K tokens correspond to roughly 6,000 English words or 1,500 lines of code . The small window forces frequent context switches and information loss.

2. Extended Thinking completely missing

What is Extended Thinking? It lets the model perform deep reasoning with a configurable "thinking budget" of 1K‑64K tokens, markedly improving performance on complex tasks.

Claude Code CLI configuration example:

{
  "model": "claude-sonnet-4-5-20250929",
  "thinking": {
    "type": "enabled",
    "budget_tokens": 10000
  }
}

Copilot CLI: No support for this configuration; the feature is disabled, which is a key reason for the intelligence gap.

3. Resource quota and timeout strategy

Claude Code CLI:

Token‑based billing ($3 per million input, $15 per million output)

Allows long‑running jobs

Supports checkpointing to save progress

Copilot CLI:

Premium request quota (Pro 300 requests/month)

Implicit "thinking budget" limits

Timeout‑interrupt mechanism

Architecture Differences

Claude Code CLI – Direct Access

User → Anthropic API → Claude Sonnet 4.5

Features:

Full 200K‑token context window

Supports Extended Thinking

Complete parameter control

Parallel tool calls

No functional restrictions

Cost: Approximately 4‑5× slower due to grep‑only retrieval and sequential tool calls.

Copilot CLI – Middle‑Layer Architecture

User → GitHub orchestration layer → Anthropic API → Claude Sonnet 4.5

Middle‑layer roles:

Model routing and switching

Cost control and quota management

Context window limitation (≈8K)

Masking advanced features (Extended Thinking)

Deep GitHub ecosystem integration

Advantages:

Multiple model choices

Strong GitHub integration

Relatively stable

Drawbacks:

Model capabilities are "trimmed down"

Severe context limits

Poor performance on complex tasks

Measured Performance Comparison

Speed Difference

Refactoring a React front‑end project (~15 files):

Claude Code CLI: 18 min 20 s

Claude Chat (manual): 4 min 30 s

Copilot CLI: ≈ 90 min (18 min × 5)

Community feedback: Copilot CLI is more than five times slower than Claude Code.

Large File Handling

Claude Code limitation: Single‑file read limit of 25K tokens. Example error:

# Single‑file read limit 25K tokens
Error: File content (28375 tokens) exceeds maximum allowed tokens (25000)

Work‑around requires offset/limit chunking, leading to repeated tool calls.

Copilot CLI issues:

8K token window forces frequent chunking

1000‑line files often stall

Sometimes hangs for 30 minutes before timing out

Why Claude Code Appears "Smarter"

1. Global view vs. local view

Claude Code: 200K‑token window, can keep many files, understands global code relationships

Copilot CLI: ~8K‑token window, can keep few files, frequently forgets prior context

2. Deep reasoning vs. quick response

Claude Code: Extended Thinking enables longer "thinking" and complex inference, suitable for multi‑step tasks

Copilot CLI: No Extended Thinking, limited budget, favors rapid answers

3. Marathon vs. sprint metaphor

Claude Code: Designed for long‑running, multi‑step tasks, allows high token consumption

Copilot CLI: Optimized for fast interactions, aborts after a short timeout to control cost

Stability Issues

Copilot CLI

After ~5 prompts, Claude Sonnet 4 stops

Frequent "I'm sorry but there was an error" messages

Sudden context loss

Officially acknowledged as a known server‑side issue

Claude Code

When using ~31% of quota, early throttling occurs

Infinite compression loop bug

Crashes on large‑file reads

Optimization Suggestions

Claude Code

Use semantic indexing: replace grep‑only retrieval with a semantic search server (e.g., Serena MCP)

Proactively manage context: /clear to clean, /compact to compress

Maintain a CLAUDE.md: project conventions, forbidden directories, common commands

Copilot CLI

Monitor quota: /usage to view consumption

Select model per task: complex tasks → Claude Sonnet 4.5, simple tasks → Haiku

Avoid launching large tasks near the limit: prevents abrupt termination

Summary

Context window: Claude Code 200K tokens vs. Copilot ~8K tokens

Extended Thinking: supported by Claude Code, absent in Copilot

Resource strategy: Claude Code – marathon; Copilot – sprint

Architecture: Claude Code – direct API access; Copilot – middle‑layer restrictions

Suitable scenarios: Claude Code for complex refactoring; Copilot for quick iterations

Many developers combine the two: Claude Code handles heavy, multi‑step tasks, while Copilot CLI is used for rapid interactions.