Claude Code /btw: Ask a Side Question Without Losing Context
Table of Contents
- What is /btw
- How to Use It
- Basic Usage
- While Claude Code Is Working
- What It Can See
- What It Can’t Do
- Why It’s So Useful
- Reason 1: Zero Context Cost
- Reason 2: No Workflow Interruption
- Reason 3: Minimal Cost
- When to Use It
- Quick Recall
- Confirming Decisions
- Understanding Current State
- Reviewing In-Context Information
- Practical Tips
- Tip 1: Make /btw Your Default for Small Questions
- Tip 2: Use It During Long Tasks
- Tip 3: Don’t Force /btw to Do What It Can’t
- /btw vs Subagents
- /btw vs /compact vs Normal Prompts
- Final Thoughts
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.
Related Articles
Claude Code Agent Loop: Dissecting the Heart of an AI Coding Assistant
How does Claude Code understand your requests, invoke tools, and self-recover step by step? A source-code deep dive into the Agent Loop's core architecture — streaming responses, parallel tool execution, auto-compaction, and error recovery.
Claude Code settings.json Explained (1): Where Config Files Live and Who Wins
A complete guide to Claude Code's configuration file system — five config sources, their file paths, priority rules, array merging vs value overriding, and enterprise managed settings delivery.
Claude Code settings.json Deep Dive (Part 2): The Permissions System
A thorough breakdown of Claude Code's permissions configuration — allow/deny/ask rule arrays, wildcard syntax, MCP tool permissions, defaultMode options, and additionalDirectories.
Claude Code settings.json Deep Dive (Part 3): The Hooks System
A thorough breakdown of Claude Code's hooks configuration — four hook types, core events (PreToolUse/PostToolUse/Stop/Notification), stdin/stdout protocol, exit code semantics, and practical examples.
Claude Code settings.json Deep Dive (4): env, Models, Auth, and Other Useful Fields
A comprehensive guide to the remaining settings.json fields in Claude Code — env variable injection, model configuration, authentication helpers, Git attribution, session cleanup, language and UI, thinking depth, auto-updates, memory system, and more.