The Claude Loop

Key Principle

Productive work with Claude is a cycle, not a command: Intent → Reasoning → Execution → Verification → Reflection (Chapter 6). The payoff is "thinking in cycles, not commands" (Chapter 6) — errors are caught when they are cheap, and the loop's byproduct becomes self-documenting design history.

Why This Matters

A developer who issues a one-shot command and walks away gets the worst of the model. Two stages carry the weight. First, reviewing the reasoning (the plan) before any execution means logical errors are caught before they are written into code. Second, verification is a process requirement, not a nicety, because the model "simulates reasoning but cannot execute actual code or external requests" (Chapter 4) — the human must run and test the output, feeding errors back. Skip these and you ship plausible-but-wrong code at speed.

Context drift is the other silent failure: as a session grows, exploratory instructions blur with durable ones and the model optimizes against goals it has effectively forgotten.

The Five Stages (Chapter 6)

Intent — state what you want clearly enough to narrow the reasoning path.
Reasoning — Claude outlines the plan; you review it before code exists.
Execution — code is generated against the agreed plan.
Verification — you run and test locally, feeding errors back (the model cannot run code).
Reflection — the closing summary becomes a knowledge artifact.

Good Examples

Reasoning-before-execution. Approve the plan first so a flawed approach is corrected before it is coded, applying the separate-reasoning-from-execution lever at workflow scale (Chapter 6).
Reflection-as-documentation. Closing summaries accumulate into lightweight documentation that tracks design decisions automatically — the loop documents itself as a byproduct (Chapter 6).
Temporary vs. persistent prompts. Keep exploratory, throwaway prompts separate from persistent system prompts that define project-long behavior, preventing context drift (Chapter 6).
Cost made visible. Read token usage so spend is observed rather than guessed; asking for "a concise summary" versus "an in-depth analysis" roughly halves output tokens — "clarity beats verbosity" (Chapter 6).

Counterpoints

One-shot commanding. Treating Claude as autocomplete skips Reasoning and Reflection and forfeits the loop's value (Chapter 6).
Trusting output without verification. Because the model cannot execute, unrun code is unverified code (Chapter 4, applied in Chapter 6).
Mixing exploratory and persistent instructions. Letting throwaway prompts bleed into durable behavior causes context drift (Chapter 6).

CLI-Command Specifics

The book's per-editor integration steps, anthropic-cli/claude login commands, API-key setup, and 429 rate-limit handling are framed around a model-via-SDK product, and are [likely inaccurate to the real Claude Code CLI]. The durable residue is the principle, not the commands:

Exponential backoff for rate limits — when calls are throttled, retry with increasing delays rather than hammering the endpoint. The mechanism is sound even if the book's specific CLI/API wiring is [likely inaccurate to the real Claude Code CLI].
Make tokens purposeful like compute cycles, and integrate the loop where you already work.

Key Quotes

"thinking in cycles, not commands." — Kilian Voss, Chapter 6

"It's an intelligent collaborator, not an infallible compiler." — Kilian Voss, Chapter 4

Rules of Thumb

Approve the reasoning before approving the code.
Always run and test before accepting output; the model cannot.
Separate temporary exploratory prompts from persistent system prompts.
Treat each closing summary as documentation worth keeping.
On rate limits, back off exponentially rather than retrying immediately.

Related References

Core Framework — Partner Not Autocomplete, Mastery Through Understanding - clarity, structure, verification levers
Prompt Anatomy — Specificity, Chain-of-Thought, and Context as Bandwidth - intent and reasoning stages in detail
Project Workflows (API, DevOps, Multi-Agent) - the loop scaled to whole projects