Claude Code /btw Command Explained: Quick Side Questions Without Breaking Flow

What is /btw

When using Claude Code, you might run into situations like these:

Claude Code is modifying a bunch of files for you, and you suddenly can’t remember the name of a config option
You want to quickly confirm a decision that was discussed earlier, but don’t want to interrupt the current task
You want to ask a small question, but don’t want that Q&A to eat up precious context space

You might just ask in the main conversation, but that creates two problems: it interrupts whatever Claude Code is currently doing, and the back-and-forth wastes context window space for no lasting benefit.

This is where the /btw command comes in.

/btw is a built-in Claude Code command that lets you ask a quick “by the way” question without interrupting the main conversation. The answer appears in a temporary overlay, never enters the conversation history, and doesn’t consume context window space.

In short: ask and move on, no trace left behind.

How to Use It

Basic Usage

In Claude Code’s interactive mode, type:

/btw What was that config file called again?

Claude Code displays the answer in a temporary overlay. When you’re done reading, press Space, Enter, or Esc to dismiss it and return to the normal conversation.

That’s it. No extra steps.

While Claude Code Is Working

The most powerful thing about /btw is this: you can use it even while Claude Code is executing a task. It won’t interrupt the current work — the side question runs independently while the main task keeps going.

For example, Claude Code is refactoring your auth module and you want to quickly check:

/btw Are we using JWT or session-based auth?

The answer pops up, you glance at it, press Esc to dismiss, and Claude Code carries on with its work. Completely uninterrupted.

What It Can See

/btw has full visibility into the current conversation context — files Claude Code has read, decisions it’s made, things you’ve discussed. So you can ask:

/btw Which files did we modify just now?

/btw What was the path for that API endpoint we discussed?

/btw What was that approach you suggested earlier?

What It Can’t Do

/btw has one important limitation: it has no tool access. It can’t read files, run commands, or search code. It can only answer based on information already present in the current conversation.

This isn’t a flaw — it’s by design. If /btw could read files and run commands, it would essentially be another full conversation, defeating the purpose of being “lightweight.”

If your question requires Claude Code to explore the codebase or perform operations, don’t use /btw — ask in the main conversation instead.

Why It’s So Useful

Reason 1: Zero Context Cost

This is the core value of /btw.

Every time you ask a question in the main conversation, both the question and answer enter the conversation history and consume context window space. In a long session, if you’ve asked a dozen small questions, those Q&As might take up several thousand tokens — information that’s completely useless for subsequent work.

/btw Q&As are ephemeral — they appear and then vanish, never entering history. Your context window stays clean.

Reason 2: No Workflow Interruption

When Claude Code is working on a complex multi-step task, dropping a message into the main conversation forces it to stop, respond to you, and then try to pick up where it left off. Sometimes that interruption causes it to lose its train of thought or skip steps.

/btw runs completely independent of the main conversation and doesn’t interrupt any ongoing operations.

Reason 3: Minimal Cost

The /btw side question reuses the parent conversation’s prompt cache, so the additional token cost is negligible. It’s essentially “free.”

When to Use It

Quick Recall

“What was that thing called again?” — this is the most typical use case for /btw.

/btw What was that test command we used?

/btw What's the name of that environment variable?

Confirming Decisions

Claude Code made a decision and you want to confirm it without starting a full discussion.

/btw Why did you choose Zustand over Redux?

Understanding Current State

You’re in a long task and want to check on progress.

/btw How many files have been modified so far? What's left to do?

Reviewing In-Context Information

You know Claude Code read a file or discussed an implementation earlier and want a quick refresher.

/btw What does that formatDate function in utils.ts look like?

Practical Tips

Tip 1: Make /btw Your Default for Small Questions

Many people default to asking everything in the main conversation. But if your question is “one-and-done” — you don’t need Claude Code to remember the answer for future work — use /btw.

The rule of thumb is simple: does Claude Code need to act on this answer later?

Yes → ask in the main conversation
No → use /btw

Tip 2: Use It During Long Tasks

When Claude Code is working on a time-consuming task (like refactoring an entire module or batch-modifying files), use /btw for any questions that come up while waiting, rather than interrupting it.

Interrupting a complex task can cause Claude Code to lose state. /btw carries zero risk of that happening.

Tip 3: Don’t Force /btw to Do What It Can’t

/btw has no tool access, so these scenarios are off-limits:

“Show me what’s in src/config.ts” → requires file reading, won’t work
“Run the tests and see if they pass” → requires command execution, won’t work
“Search for where this function is used” → requires code search, won’t work

For these needs, ask in the main conversation or have Claude Code use a subagent.

/btw vs Subagents

/btw and subagents are an interesting pair of “opposites”:

	/btw	Subagent
What it sees	Full current conversation context	Almost nothing (starts with empty context)
What it can do	Nothing (no tools)	Everything (full tool access)
Impact on main context	Zero impact, no trace	Returns only a summary
Best for	Questions about “known information”	Going out to “discover new information”
Analogy	Flipping through your notes	Sending someone out to investigate

One-line summary: /btw asks about the known; subagents find the unknown.

Want to recall something Claude Code already read → /btw. Want Claude Code to explore code it hasn’t seen → subagent.

/btw vs /compact vs Normal Prompts

	/btw	/compact	Normal Prompt
Enters history	No	Compresses history	Fully enters
Context cost	Almost none	Frees context	Normal cost
Tool access	None	N/A	Full
Interrupts current task	No	Yes	Yes
Best for	Quick Q&A	Context slimming	Tasks requiring Claude Code to take action

My recommendations:

Don’t need Claude Code to take action, just confirming something → /btw
Context is too full, need to free up space → /compact
Need Claude Code to read files, edit code, or run commands → normal prompt

Final Thoughts

/btw is one of the “smallest” commands in Claude Code — simple usage, single purpose, no tool access at all. But it’s precisely this minimalist design that makes it a powerful context management tool.

The context window is Claude Code’s most precious resource. Every unnecessary Q&A eats into that resource. The philosophy behind /btw is simple: not every question deserves a place in the conversation history. Some questions just need an answer, not a permanent record.

The name itself is perfect — “by the way,” just a quick aside. It’s meant to be casual, lightweight, and ephemeral.

Next time you’re using Claude Code and suddenly need to confirm a small detail, resist the urge to type in the main conversation. Try /btw instead — ask, press Esc, keep working. You’ll find that this “leave no trace” style of questioning is surprisingly satisfying.