Skip to content
Datfx Labs Claude Guide

BTW: Side Questions Without Derailing

/btw lets you ask Claude a quick question without adding it to the conversation history. The answer appears inline, the agent’s current task context is untouched, and the session continues exactly where it was.

It is the conversational equivalent of turning to a colleague and saying “hey quick question” — and having them answer without losing their place in the work they were doing.

Syntax

Terminal window
/btw <question>


# Examples
/btw what's the flag for verbose output in jest?
/btw what does SIGTERM mean again?
/btw is useState a hook or a component?
/btw what's the keyboard shortcut to open the git panel in VS Code?

The response is shown immediately below your question. No follow-up, no history entry, no context modification. The agent’s next response continues from the state before your /btw question.

How It Differs from a Normal Question

A normal question becomes part of the conversation:

You:   "What's the --watch flag for jest?"
Claude: "[explanation]"
You:   "Now continue the refactor."
Claude: "[may reference the jest discussion, context has shifted]"

A /btw question is ephemeral:

You:    /btw what's the --watch flag for jest?
Claude: "--watch runs tests related to changed files continuously."
        [this exchange does not appear in the conversation history]
You:    [agent continues refactor from exactly where it was]

The agent has no memory of the /btw exchange. It did not happen, as far as the session context is concerned.

Primary Use Case: Questions During Long Tasks

The typical scenario: Claude is in the middle of a multi-step operation — a large refactor, a debugging session, a migration — and you have a quick question that has nothing to do with the task. You do not want to inject noise into the conversation, but you need the answer now.

Example workflow:

[Claude is 6 steps into a 10-step database migration]


You:    /btw what's the postgres syntax for adding a column with a default value?
Claude: "ALTER TABLE table_name ADD COLUMN col_name type DEFAULT value;"


[Claude continues step 7 of the migration, unaffected]

Without /btw, asking that question mid-task would inject it into Claude’s working context, potentially causing the agent to think you want to change direction.

What /btw Is Good For

  • Syntax lookups (“what’s the flag for X”)
  • Quick definitions (“what does ETIMEDOUT mean”)
  • Tool/command reminders (“what’s the shortcut for Y”)
  • Sanity checks (“is this the right approach for Z, roughly?”)
  • Documentation pointers (“where in the React docs is useReducer explained?”)

The pattern: short question, short answer, move on.

What NOT to Use /btw For

Do not use /btw for things that should actually change the task:

Terminal window
# Wrong — this is a task direction change, not a side question
/btw actually can you use SWR instead of React Query for this?


# Right — ask it directly so Claude incorporates it into the plan
"Actually, switch to SWR instead of React Query for this refactor."

Do not use /btw for multi-part questions:

Terminal window
# Wrong — this is a real conversation, not a side note
/btw can you explain the tradeoffs between REST and GraphQL for our use case and which you'd recommend?


# Right — ask it normally, it deserves context and a real response
"What are the tradeoffs between REST and GraphQL for a real-time dashboard?"

Do not use /btw when you want Claude to remember the answer:

If the answer to your side question is something Claude should carry forward (a decision, a constraint, a fact about the codebase), ask it normally so it enters the conversation history.

Voice + BTW

/btw pairs naturally with voice coding. When you are dictating a long task and need a quick answer, say “btw [question]” — Claude Code recognizes the /btw prefix in voice mode and treats the question as ephemeral.

[You are dictating a feature implementation by voice]


You:   "btw — what's the default timeout on fetch?"
Claude: "30 seconds in most browser environments; none in Node.js fetch."


[You continue dictating the feature — the exchange did not interrupt the session]

This is particularly powerful in voice mode because injecting questions into a dictated stream would otherwise require stopping, switching to keyboard, and resuming — breaking the voice flow entirely.

Gotchas

The answer is also ephemeral. Claude will not remember that it answered your /btw question. If you ask the same question again later, it will answer fresh. This is by design — side questions should not accumulate in context.

Not for decisions. If your “side question” is actually a decision point (“should we use X or Y for this?”), ask it as a real question. Decisions need to be in the conversation history so Claude can reason about them going forward.

Token usage. Even though /btw questions do not appear in conversation history, they do consume tokens for the response. In a very long session near context limits, even ephemeral exchanges add up.