Skip to content

The conversation

What the transcript shows, and how much of it.

A message of yours has the look of the composer it was written in: the same surface, lighter than the page, the same border and corners. Code is the dark surface, so the two are never mistaken for one another.

A long message is clipped to Preview lines, with Show more / Show less. Hovering a message of yours gives, under it, how long ago it was sent, then Copy message and Fork conversation from here (see Sessions).

Chips on the bubble show what went with it: the editor file with its line or range (Program.cs:183, Program.cs:35-48), images, attached files. Clicking the file chip opens it at those lines; an image opens the lightbox, which has Copy image. A slash command is shown as you typed it.

With Sticky user messages on, the message that opened the exchange stays pinned at the top while its answer scrolls under it, so you always see what is being answered. Expanded while pinned, a long message scrolls inside itself.

Two states are marked:

  • A message Claude has not read yet is dimmed and waits at the bottom of the conversation, with a cross in place of Fork: see Messages sent while Claude works.
  • A turn you stopped leaves a [Request interrupted…] line with an orange bar down its left. Nothing else of yours has that bar, so the places where you stopped Claude are easy to find again.

Collapsible rows, one per tool call. An open row has an IN and an OUT cell (ERR on a failure), each with a copy button; clicking a cell opens its full text in a Visual Studio document. Clicking a file path opens the file in VS.

  • Read shows its line range and opens the file there.
  • Edit shows an inline diff; on opening the file the selection lands on the lines that changed, taken from the patch the CLI itself computed, so it is right even after the edit has been applied and the file touched again (Select lines when opening file). Its title carries the counts (+3 −14), or Edit failed.
  • Write shows the content itself, with the line count in the title: see Reviewing changes.
  • Bash and PowerShell commands are never clipped and are highlighted; their output stays a preview even with the row open, the full text being one click away.
  • Grep, Glob and WebSearch show a count (12 matches, No files) that opens the full result.
  • MCP tools read MCP Tool then server · tool, with input and output as indented, highlighted JSON, never clipped.
  • Agent rows group a sub-agent’s own tool calls: see Sub-agents.

A failed row has a Show error details button; with Show tool errors inline on, the error is shown under the output instead. A row left unfinished in a reopened session is shown as failed.

A failed Bash row, an Edit with its diff, and a Write showing the new file’s content

How much of the work the transcript shows, from the View mode slider in the / menu.

Mode Command Shows
Full /vm:full or /vm:0 every row
Focus /vm:focus or /vm:1 every reply; each run of tool calls and thinking between two of them folds into one row (5 tool calls · 1 failed, Running Bash… while it works) that opens in place
Hide tools /vm:hide or /vm:2 the tool rows are dropped altogether; thinking rows stay

The commands set a mode outright, without leaving the keyboard: type /vm:1 and press Enter. The number is how much is hidden, 0 nothing and 2 the most. They work with a draft in the composer too: a / that starts a word opens the menu anywhere in the text, and what you typed for the command is removed once it has run. /view, /hide or /tools bring the slider itself to the top of the list. The mode is shared by every open chat.

Kept in every mode: your answers to questions, plan decisions, the task list, and a call waiting for your approval. In Focus and Hide tools an answered question starts closed, down to its header (Question · Answered); its chevron opens it.

A fold opened while its run was still working closes again when the turn ends.

The task list in the conversation

Focus: a run of tool calls folded into one row

Edit rows show a diff with the file’s own line numbers and the context around each change, syntax-highlighted, with the changed words marked inside an edited line. Clicking it opens the change in Visual Studio’s native side-by-side diff. See Reviewing changes.

With Thinking on, the model’s reasoning appears as a closed row above the answer: Thinking… 12s while it runs, Thought for 12s · ~88 tok afterwards. Open it to read the reasoning.

A thinking row, closed

When the CLI compacts the conversation the spinner reads Compacting…, and the transcript gains a separator: Compacted chat · auto · 84k tok freed. Open it to read the summary that replaced the earlier messages, fetched when first opened. A compaction that fails leaves a red Compaction failed: … line.

An answer is rendered as it arrives, not when it ends. The dot in front of it blinks while it is being written and turns grey when it is done; a red dot means the API refused the turn, and the text beside it says why.

Pointing at a finished answer shows a row under it: copy, read aloud, how long ago it was written, and what the turn cost when that option is on.

Text and structure

  • Headings, lists, block quotes and rules, as Markdown writes them.
  • Tables are framed, with the header on one line. A table wider than the pane scrolls sideways on its own, without moving the rest of the answer.
  • Inline code is a pill lighter than the page, so a command or a file name stands out of the sentence it sits in.

Code

  • Fenced blocks are highlighted for their language, and a block with no language keeps its spaces, so a diagram drawn in characters stays aligned.
  • A long line scrolls inside its block instead of wrapping.
  • A diff block colours the added and removed lines.

What becomes a link

  • A file with a line: ClientEvents.cs:208 opens that file in Visual Studio; see Clickable file references.
  • A pull request, an issue, a commit or a release on GitHub, GitLab, Azure DevOps or Bitbucket: shown short, as acme/widgets#312, with the service’s mark and the full address on hover; see Links to pull requests and issues.
  • Any other address opens in your browser.
  • Nothing inside a fenced block is turned into a link: a path in an example command stays text.

Copying

  • Every answer, every message of yours, every tool row and every code block has a copy button, shown when you point at it.
  • A table copies as Markdown, pipes and alignment included, so it parses back as the same table wherever you paste it.

Not rendered

Formulas written in LaTeX and Mermaid diagrams are shown as Claude wrote them, the diagram as a code block.

Also here: an image in the conversation opens in a lightbox, and an empty chat shows a welcome screen.

Not everything in the conversation is a message.

  • A change of model: Switched to Opus 5.5, as a small label between two rules, where you made it.
  • A session reopened after a long pause says so under its last message: Idle 3h 2m. Prompt cache likely expired: your next message costs more… See The prompt cache.
  • The output of a slash command (/config, /model, Unknown command) is shown as the terminal would print it: monospace, with a bar down its left, aligned as the command wrote it.
  • An error is a red box with a red bar: a failure reported by Claude Code, a turn that ended on one, or a slash command that wrote to its error stream. A command that only reports a problem in its normal output is shown like any other output: the chat has no way to tell it from a success.

Red and orange each mean one thing here: red is something that went wrong, orange is a turn you stopped yourself.

The spinner counts the seconds while the turn runs, and the output tokens received so far (↓ 1.2k tok, an estimate).

With Show cost and duration on, the row of actions that appears when you hover a finished answer also carries what the turn cost: $0.3260 · ↑ 1.2k ↓ 84 tok · 3.2s (cost, input and output tokens, time). A turn read back from history shows its tokens only: cost and duration are not stored in the session file.

An Agent row carries a running clock while its sub-agent works and, once it has finished, the run’s own totals (1m 23s · 12k tok · 8 tools), whatever the option says.

There are two places: session notices at the top of the chat, turn notices above the prompt. Each shows at most three; information and success fade after 7 seconds, warnings and errors stay until you dismiss them.

  • A turn that ends without an answer says why: Turn limit reached, Budget limit reached, Usage limit reached, Prompt too long, Stopped by a hook, API error, Model error. A turn you stopped yourself shows none.
  • If the CLI process exits: Claude Code process exited (code N), with a View logs button. It clears when the CLI starts again, which your next message does. See Troubleshooting.
  • A file that will not open says so, with the reason.
  • Rate-limit notices are in Context, usage & statistics.

A speaker button on each answer reads it out with the system voice (Web Speech, no extra install); click to pause, click to resume. The markdown is spoken as plain prose: no “asterisk asterisk”, no code blocks recited. One reading at a time: starting another stops the first.

/code-review reports its findings as a readable list: severity first, each with its file and line as a link that opens there, instead of the raw call data. The row grows to fit them, so nothing hides behind an inner scrollbar; after a --fix run it also says what each finding became.

  • Lazy history: the transcript is read from the .jsonl on demand: the newest page (batch of 50) first, older pages only as you scroll up, and heavy blocks (images, sub-agent transcripts, full diffs) fetched only when opened. Nothing is held in memory up front: long sessions open fast and stay light.
  • Jump to the latest: scrolling up puts a button in the corner that returns you to the bottom of the transcript.

Preview lines, Collapse tool results, View mode, Sticky user messages, Show cost and duration, Select lines when opening file, Show tool errors inline and Chat font size are under Options → Chat. The font size applies to the whole conversation: messages, answers, tool rows and their code.