Multi-turn Conversation Strategies

Plan mode usage; building context through dialogue; strategic resets; the Boris Cherny workflow

Single-turn interactions suffice for simple tasks. Complex development work requires extended dialogue multiple exchanges that build toward sophisticated outcomes.

Plan mode for structured discovery

Plan mode separates research and planning from execution. The agent can observe, analyze, and propose but cannot modify files or run commands.

claude --permission-mode plan

Or press Shift+Tab twice to cycle: Normal → Auto-Accept → Plan

What Plan mode enables: Reading files, searching with Glob and Grep, fetching web content, analyzing architecture, generating implementation plans.

What Plan mode prevents: Creating, modifying, or deleting files. Executing shell commands. Making any changes to system state.

When to use plan mode

Scenario	Benefit
Complex features with unclear requirements	Discovery phase reveals scope and dependencies
Architectural decisions	Safe exploration before commitment
Multi-file changes with unclear impact	Mapping dependencies without risk
Unfamiliar codebases	Building understanding before modification
High-stakes changes	Planning reduces errors in execution

Many experienced practitioners now use plan mode almost exclusively when starting new features. The planning phase produces structured output typically a plan.md file with task breakdown, dependencies, and execution order.

Building context through dialogue

The research-plan-implement pattern

Research phase Direct the agent to read relevant files without writing code yet
Planning phase Request a plan for the implementation approach
Verification phase Ask clarifying questions and refine the plan
Implementation phase Execute the agreed approach
Validation phase Run tests and verify behavior

This sequence front-loads understanding, reducing corrections later.

Start with high-level requests, then refine based on responses:

Turn 1: "Add user authentication to the API"
Turn 2: "Use JWT tokens with RS256 signing, not HS256"
Turn 3: "Store refresh tokens in Redis, not the database"
Turn 4: "Add rate limiting on the token refresh endpoint 10 requests per minute"

The agent accumulates requirements across turns, producing a more complete implementation than a single prompt could specify.

Subagent delegation

For large investigative tasks, delegate to subagents:

"Use a subagent to analyze all authentication-related files and summarize the current approach before we add the new feature"

Subagents operate in isolated context, returning only relevant findings and preserving main conversation capacity.

Strategic context resets

Signals that a reset is needed:

Agent suggestions become nonsensical or repetitive
Corrections fail to stick the agent reverts to old patterns
Tool calls no longer correspond to requests
Error messages and debugging attempts fill the context

Productive reset patterns

Commit-and-clear. After completing a task and committing code, clear the context before the next task. Git history preserves decisions.

Summarize-and-restart. Ask the agent to summarize decisions, changes, and outstanding issues. Start new session with this summary as initial context.

Selective continuation. Architectural patterns belong in CLAUDE.md where they persist. Task-specific exploration belongs in conversation and resets with it.

The 80% guideline: Reset before reaching 80% of practical capacity (~160k tokens for Claude Code) to maintain quality headroom.

The Boris Cherny workflow

Boris Cherny, creator of Claude Code, publicly shared his workflow in late 2025.

Parallel session management. Runs five Claude Code sessions in parallel (numbered 1-5 in terminal tabs), plus 5-10 sessions on claude.ai/code. System notifications alert when sessions require input.

Plan mode as default. "If my goal is to write a Pull Request, I will use Plan mode, and go back and forth with Claude until I like its plan. From there, I switch into auto-accept edits mode and Claude can usually 1-shot it."

Model selection. Uses Opus 4.5 with thinking enabled for all work. "A wrong fast answer is slower than a right slow answer."

Verification as force multiplier. "Give Claude a way to verify its work. If Claude has that feedback loop, it will 2-3x the quality of the final result."

Shared memory through CLAUDE.md. The Claude Code team maintains a single CLAUDE.md file at approximately 2,500 tokens. "Anytime we see Claude do something incorrectly we add it to the CLAUDE.md."

Dialogue patterns that work

Explicit thinking requests "Think carefully about this" or "reason through the tradeoffs" triggers more deliberate processing.
One issue per turn Bundling multiple unrelated issues creates confusion. Separate turns for separate concerns.
Showing rather than telling Provide examples instead of abstract instructions. "Use getUserById not getUser" beats "use more descriptive names."
Test-driven specification Ask for tests based on expected input/output before implementation. Tests serve as specifications.

Conversation anti-patterns

Patterns to avoid:

Specification creep spiral Adding requirements incrementally without consolidating creates confusion
Debugging death spiral Extended debugging sessions accumulate failed attempts that bias future suggestions. If three attempts fail, reset
The everything prompt Attempting to specify every detail in a single massive prompt overwhelms processing
The context hoarder Continuing sessions indefinitely trades theoretical value for real quality degradation

Session continuity across tools

Claude Code to Codex handoff. Export requirements from Claude Code planning and import them as Codex task specifications. Planning benefits transfer even when execution moves to a different tool.

Documentation as persistent memory. Decisions that matter beyond the current session belong in files, not conversation. Update CLAUDE.md, AGENTS.md, or architecture documentation during sessions.

Commit messages as context. Well-written commit messages become context for future sessions. Agents reading git history inherit understanding from past work.