For users of Claude Code, either the Desktop panel or the CLI (claude). You delegate coding tasks to an agent that reads files, runs commands, edits code, and iterates. The token economics differ meaningfully from chat, and the failure modes are sharper.

How Claude Code is different

Where chat is one user message in, one assistant response out, Claude Code runs agentic loops. A single instruction like "implement OAuth login on the staging environment" can trigger dozens of internal sub-turns: read this file, run that command, parse the output, decide what to do next, edit a file, re-run the test, read the error, etc. Each of those sub-turns sends the full accumulated context and adds its own results back into the conversation history.

Diagram: one user turn becomes N internal turns

flowchart TB
    User([User instruction:<br/>'implement OAuth login on staging'])
    User --> T1[Internal turn 1<br/>Read auth.py]
    T1 --> T2[Internal turn 2<br/>Run grep on session middleware]
    T2 --> T3[Internal turn 3<br/>Edit auth.py with JWT logic]
    T3 --> T4[Internal turn 4<br/>Run tests, parse failure]
    T4 --> T5[Internal turn 5<br/>Read failing test fixture]
    T5 --> T6[Internal turn 6<br/>Fix fixture]
    T6 --> T7[Internal turn 7<br/>Re-run tests]
    T7 --> TN[… Turn N …]
    TN --> Result([Final response to user])
    style User fill:#dbeafe
    style Result fill:#dcfce7

Each arrow represents one full payload transmission. The context envelope grows at every step because every tool result (grep output, file content, error trace, test result) gets added to the conversation history and travels forward on every subsequent step.

The implications are immediate:

• Tool call results stay in context. Every file Claude Code reads, every shell command it runs, every test output it observes, every error trace it parses, gets added to the conversation history and travels forward on every subsequent step. A single grep result can add hundreds of tokens that never leave the session.
• Long tasks accumulate context fast. A 20-step refactoring task can easily generate 30,000 to 100,000 tokens of intermediate state.
• Errors compound. A confused step that requires correction does not just add the correction; it adds the confused step plus the correction plus the error trace plus the explanation, and they all travel forward.

Three pressures, not two

Claude Code users face all three of:

• Context window pressure. Long sessions blow the 200K window mid-task and degrade in quality before they error out. Sonnet 4.6 and Opus 4.6/4.7 offer 1M tokens at standard pricing, but in some Claude Code configurations the 1M window may not be enabled by default; check /status.
• Quota pressure. The 5-hour and weekly limits on Pro and Max plans are shared between Claude.ai and Claude Code. A single agentic task can consume 10 to 30 messages worth of rate-limit weight because of the tool-call multiplication.
• Wall-clock time. Every tool call is a round trip. Reading more files means waiting more.

The CLI commands that matter

The CLI gives you direct levers the Desktop panel does not. If you use Claude Code seriously and you are not in the CLI, you are leaving most of your control on the table.

• /compact replaces the full verbatim conversation history with a model-generated summary. A 50,000-token session can compact to 3,000 tokens of summary. Every subsequent turn pays 3,000 tokens of history instead of 50,000. This is the most impactful single action available in the CLI for long-running sessions. Use it after every completed major task. Do not wait until the window is full. Caveat: avoid /compact mid-task during fragile debugging or refactors where exact prior code, file paths, or specific error traces matter. Summaries can lose critical detail and you only discover the loss when the next edit goes wrong. For those situations, finish the task or stash explicit notes before compacting.
• /clear drops conversation history without summarising. More aggressive than /compact. Use when the prior context is genuinely irrelevant to whatever you are about to do.
• --print runs a single non-interactive query and exits. No history, no session overhead. The most efficient pattern for stateless tasks: "summarise this file", "generate a test for this function", "what does this error mean". No /compact needed because there is no session.