Library
Claude Code Documentation (June 2026) · 8 of 15
Claude Code Documentation (June 2026)
ai CRITICAL

Claude Code Core Framework

Claude Code Documentation (June 2026) Anthropic
context-window workflow scaling safety agentic

Version Snapshot

This skill reflects the Claude Code official documentation, June 2026. Verify against live docs — many features are experimental/beta and move fast.

  • Default model: Opus 4.8 (runs at high effort; raise with /effort xhigh). Also available: Opus 4.7, Opus 4.6, Sonnet 4.6, Haiku 4.5, and Fable 5 (1M context, v2.1.170+).
  • Version cluster: features here land across v2.1.94–v2.1.181. Specific gates are noted where they matter (e.g. Advisor needs v2.1.98+; agent-team default mode changed to "in-process" in v2.1.179).
  • On Bedrock the opus alias resolves to Opus 4.6 unless ANTHROPIC_DEFAULT_OPUS_MODEL is set to the Opus 4.8 ID (us.anthropic.claude-opus-4-8). (p. Chunk 008)

Key Principle

Claude Code is an agentic terminal coding tool: unlike a chatbot, it reads files, runs commands, makes changes, and works through problems autonomously while you watch, redirect, or step away (Section: Best Practices). The single constraint behind nearly every best practice is the context window — it holds the entire conversation (every message, file read, command output) and fills fast; a single debugging session can burn tens of thousands of tokens. As it fills, "Claude starts forgetting earlier instructions and making more mistakes." It is the most important resource to manage (p. Chunk 013).

Why This Matters

If you treat context as free, performance silently degrades: instructions get lost, mistakes multiply, and you become the bottleneck. Most guidance — specific prompts, @-references, CLI tools over MCP, skills over CLAUDE.md, subagents, /clear//compact — exists to put the right tokens in and keep noise out (p. Chunk 014, 015). The other half of the framework is closing the verification loop so an agentic run can finish correctly without you grading every turn.

Good Examples

  • Explore → plan → code. Separate research/planning from implementation so Claude doesn't solve the wrong problem. Use plan mode (read-only: Claude reads and answers without editing, producing a plan first) to spend cheap read-only tokens settling the approach before committing expensive edit/test/commit tokens. Press Ctrl+G to open the plan in your editor; switch to default mode to implement (p. Chunk 014). Rule: "If you could describe the diff in one sentence, skip the plan."
  • Give Claude a way to verify its work. Give it a check that returns pass/fail it can read — test suite, build exit code, linter, fixture diff, or a screenshot compared to a design. "Without a check, 'looks done' is the only signal and you become the verification loop." Verbatim escalation, more setup → less attention: (1) ask Claude to run the check and iterate in one prompt; (2) set the check as a /goal condition (a separate evaluator re-checks every turn); (3) a Stop hook runs your check as a script and blocks the turn until it passes — Claude Code overrides it after 8 consecutive blocks; (4) a verification subagent / dynamic workflow re-checks in a fresh context (p. Chunk 013).
  • Verification prompt pattern (verbatim): instead of "the build is failing," say "the build fails with this error: [paste error]. fix it and verify the build succeeds. address the root cause, don't suppress the error" (p. Chunk 013).

Counterpoints

  • Don't skip explore/plan on large or unfamiliar changes — jumping straight to code risks the wrong solution discovered only after edits. Conversely, plan mode is pure overhead on a typo or rename (p. Chunk 014).
  • Don't assert success — show evidence. Have Claude produce test output, command + result, or a screenshot, not a claim of "done" (p. Chunk 013).
  • Don't over-scale. The scaling ladder costs more tokens at every rung; reach for the next rung only when the current one can't do the job (p. Chunk 003).

Key Commands & Config

# Scaling ladder (lowest cost → highest): single session → subagents →
#   background sessions (claude agents) → agent teams → dynamic workflows
# Layered safety (outer → inner): managed settings → permissions →
#   sandboxing → auto mode (classifier) → hooks
/effort xhigh        Raise reasoning effort (default Opus 4.8 = high)
plan mode            Read-only explore/plan; Ctrl+G opens plan in editor
/goal                Session-level verification gate (re-checked each turn)
Stop hook            Deterministic gate; overridden after 8 consecutive blocks
/code-review         Bundled adversarial review of the current diff (fresh subagent)

Rules of Thumb

  • Treat the context window as the scarce resource; every decision is "does this token earn its place?"
  • Explore and plan before you let Claude code anything non-trivial.
  • Always give Claude a pass/fail check it can read — that is what lets an unattended run finish correctly.
  • Climb the scaling ladder one rung at a time; don't default to teams or workflows.

Related References