Conversational Development With Claude Code — Part 8: Claude Code 2.0 + Sonnet 4.5 (Checkpoints, VS Code, and the New Shape of “Thinking”)
TL;DR — Claude Code 2.0 quietly changes the ergonomics of AI-assisted engineering: a proper VS Code surface, searchable prompt history, and checkpoints that let you roll back Claude edits without touching Git. Pair that with Sonnet 4.5—built to stay coherent for long multi-step tasks—and you get a workflow that feels less like “chatting with a model” and more like running an opinionated engineering toolchain.
This chapter is about control surfaces:
- updating the CLI + VS Code extension,
- using checkpoints as a safety net for exploration,
- and adopting the simplified “Thinking” toggles without losing rigor.
Why this update matters (beyond “it looks nicer”)
Most developer productivity wins don’t come from new features.
They come from removing micro-friction:
- “I want Claude in the IDE, not in a separate terminal pane.”
- “I want to explore aggressively, but I need a reliable undo.”
- “I want to reuse a proven prompt from last week without hunting chat logs.”
- “I want deep reasoning when it matters, without turning every request into a research paper.”
Claude Code 2.x is essentially an answer to these pressures: it turns the experience from a clever REPL into something closer to an editor-native system.
Step 1 — Update Claude Code from the CLI (the boring part that prevents weirdness)
Your CLI is still the anchor. Even if you live inside VS Code, the CLI is the thing that owns:
- session storage,
- agent configuration,
- checkpoints,
- permissions,
- and tool execution.
Updating is a first-class command:
claude update
It checks for the latest version and updates in place.
Practical note: the jump from 1.x to 2.x isn’t just a version bump. Expect behavior changes—especially around interface, checkpointing, and how you interact with “thinking” modes.
Step 2 — Update the VS Code extension (and understand what changed)
Claude Code 2.x isn’t only terminal-driven anymore. The VS Code extension becomes a real surface:
- a sidebar panel,
- inline diffs,
- and a more graphical interaction model.
If you’re updating via the Marketplace, you’ll see the extension listed as Claude Code for VS Code by Anthropic.
What this changes in practice
The IDE integration isn’t “nice-to-have”. It changes the feedback loop:
- You see file edits as diffs, not as text dumps.
- You can approve changes in a way that feels like reviewing a PR.
- You can stay inside the editor’s mental context: file tree, search, references, errors.
When AI assistance is embedded into your primary work surface, your brain stops context-switching. And context-switching is where velocity goes to die.
Step 3 — Checkpoints: the feature that makes you braver
The single most underappreciated engineering skill is safe exploration.
Not safe as in “be conservative.”
Safe as in: try bold changes, but keep a reversible path.
Claude Code’s checkpointing system is exactly that. It automatically saves your code state before Claude edits, and lets you rewind. The built-in docs describe two common entry points:
- tap Esc twice to open checkpoint history
- or use the
/rewindcommand
The flow (as it actually feels in a real session)
1) Ask for a change (a refactor, a spec edit, a rewrite).
2) Claude edits files.
3) You review.
4) If the change is wrong—or even almost right but not worth salvaging—rewind.
When you rewind, you can choose what you restore (depending on the UI you’re using):
- restore code + conversation,
- restore only code,
- restore only conversation.
This is not a Git replacement. It’s closer to an “AI edit stack”—a local undo system for agent-driven changes.
And psychologically, it’s huge: it removes the fear of trying.
My rule: If a change is exploratory and I’m not sure I want it, I lean on checkpoints first.
If the change is confirmed and intentional, I commit it.
Step 4 — Prompt history search: stop retyping what already worked
Every strong Claude Code workflow eventually becomes a library of prompts.
The CLI supports continuing and resuming sessions (-c, -r) and the refreshed terminal experience emphasizes searchable prompt history.
Even if your exact keybinding differs by platform, the principle is stable:
- you should be able to bring back a previous instruction,
- re-run it in a new context,
- and iterate without rewriting the phrasing.
This is how prompt engineering becomes prompt ops: repeatability, reusability, and traceable evolution.
Step 5 — The “Thinking” modes changed. The engineering discipline didn’t.
Older training materials often describe explicit keywords like:
thinkthink deeplyultrathink
Depending on your current Claude Code build, those discrete keywords may be deprecated in favor of a simpler, UI-driven Thinking On/Off toggle.
This matters because it removes ceremony. It also removes excuses.
When “deep thinking” becomes a keypress instead of a ritual phrase, the question changes from:
“Should I remember the right magic words?”
to:
“Is this a problem that deserves reasoning budget?”
That’s the real skill.
When I toggle Thinking ON
- impact analysis,
- architectural design,
- migration planning,
- security review,
- debugging a non-local failure,
- anything with cross-cutting consequences.
When I keep it OFF
- formatting,
- mechanical refactors,
- documentation polish,
- repetitive code generation,
- file moves and renames.
Reasoning is a resource. Spend it where consequence is high.
Step 6 — Sonnet 4.5: why long-running tasks finally feel stable
The Sonnet 4.5 release notes emphasize improved coding performance and longer focus, and the model is available under the claude-sonnet-4-5 name in Anthropic’s model catalog (release date shown as 2025-09-29).
If you’ve ever run an agentic workflow for more than an hour, you’ve felt the failure modes:
- drift,
- accidental rework,
- shallow repetition,
- forgetting earlier constraints.
The promise of a stronger coding model is not “it writes better functions.”
It’s that it stays coherent across a sequence.
What changes in day-to-day engineering
With a stable model + checkpoints:
- You can let Claude tackle multi-step chores (docs → refactor → tests → fix) without the same anxiety.
- You can interrupt, adjust the prompt, resume, and keep continuity.
- You can plan with subagents (Part 7) and actually trust the main agent to orchestrate.
This is how “AI pair programming” grows into “AI-assisted engineering”: more loop, less gimmick.
A small but important note on safety: checkpoints aren’t a free pass
Checkpoints rewind Claude’s edits. They do not magically protect you from:
- destructive bash commands,
- dangerous file operations you approve,
- or mistakes you merge into main.
So keep the same discipline:
- read the command before running it,
- prefer non-destructive verification steps,
- and treat permissions as your control plane.
Checkpoints are a seatbelt.
You still drive.
Suggested mini-exercise (10 minutes)
If you want to feel the update in your hands—not in theory—do this:
1) claude update
2) In VS Code, update Claude Code for VS Code
3) Ask Claude to make a small change to a Markdown spec
4) Rewind it via Esc Esc (or /rewind)
5) Re-run the prompt with a refined constraint
6) Save the final version and commit
The point isn’t the change.
The point is rehearsing the loop.
Final thoughts
Claude Code 2.0 is not an “AI update.” It’s a workflow update.
It moves the center of gravity from:
- conversation as interface to
- tooling as interface.
And with Sonnet 4.5 under the hood, the toolchain becomes stable enough to support longer arcs of work—where real software lives.
In the next parts of this series, we’ll take this foundation and turn it into:
- repeatable spec-driven development,
- agent teams with explicit boundaries,
- and repository-native documentation that survives beyond the chat scroll.
— Written by Cristian Sifuentes
Full‑stack engineer · AI‑assisted systems thinker
Top comments (0)