Claude Code's plan mode is great. Then what?

The best habit to form in agentic coding right now is Claude Code's plan mode: Shift+Tab twice (or /plan), the agent goes read-only, explores your codebase, and writes an implementation plan before it touches a file. It separates thinking from doing. Adopt it — genuinely. Then look at what happens the moment the plan appears.

What plan mode gets right

A lot. It's read-only, so nothing changes while you're still thinking. It loads context — the agent reads the files it'll need and discovers how they connect — so by the time it exits, it knows what it's working with. And it puts a plan in front of you before the code, so you review intent instead of a diff. It's close to the single highest-leverage keystroke in the tool.

Where it stops: the plan is a blob you approve

When the plan appears, your options are approve it or open it in your editor to change the text. But the plan is where every decision lives, and a text blob is a poor place to work decisions. You can't comment on one specific line. You can't ask “why this approach?” and get a threaded answer. The agent can't flag “I assumed the datastore is Postgres — right?” in a spot you resolve in place. A teammate can't weigh in. And the instant the session ends, the plan and the reasoning behind it evaporate. You're approving a monologue.

The plan is a conversation

inplan opens the plan as a reviewable document. Highlight a span and leave a comment; the agent replies in the thread. It raises its own open questions inline — as actual questions with choices (pick one, pick many, or answer in your own words) — and you resolve each where it sits, like a pull request. The plan becomes the two-way exchange plan mode gestures at but a terminal can't hold. Same instinct — think before you build — with a surface built for the thinking.

Plan mode gives you a plan to approve. The decisions in it deserve a conversation, not a keystroke.

It persists — and other people can be in it

A plan in inplan is durable. The decisions and the reasoning behind them stay, so next week — or a fresh agent with an empty context window — reads the same resolved plan instead of re-deriving it. And on a team the reviewer isn't only you: a product manager, an architect, a teammate can each answer the questions in their domain on the same document, before anyone writes a line.

Use them together

This isn't plan mode or inplan. Let plan mode draft the plan from your codebase; bring it into inplan to resolve the open questions with the agent (and your team); hand the resolved plan back to Claude Code to implement. Plan mode gets you a plan. inplan gets you a decided one — which is what makes the build that follows go straight instead of looping back through rework.

Think before you build — then decide before you build

Plan mode won the first argument: don't let the agent code before it has a plan. The next one follows naturally — don't let it build before the plan's open decisions are actually settled. A keystroke approves a plan. A conversation resolves one. Give your plan the second, and everything downstream inherits it.