How to Use the /btw Command in Claude Code

Mar 12, 2026

Purpose

I want to ask quick questions in Claude Code without polluting my conversation history. The /btw command solves this by providing a quick lookup overlay that doesn’t add to my main context.

The Problem: Context Pollution

When working with Claude Code on complex tasks, my conversation history becomes a valuable asset. Every question I ask gets added to the context window. This creates two problems:

Problem 1: Context Bloat

Tangential questions consume context window space
Important decisions get buried in noise
Session becomes harder to navigate

Problem 2: History Clutter

Finding previous decisions requires scrolling through off-topic exchanges
The conversation loses focus

Here’s a real scenario:

I’m in the middle of a complex refactoring. I wonder “what’s the pattern for error handling in this codebase?” I ask Claude, get an answer, but now my refactoring conversation has a random detour about error handling patterns.

The Solution: /btw Command

The /btw command opens a quick lookup overlay:

/btw <your question>

What it does:

Opens a quick lookup overlay
Queries Claude using session context + Claude’s knowledge
Returns answer without adding to conversation history
Dismisses cleanly with Escape

What it does NOT do:

Does NOT use tools (no file access, no command execution)
Does NOT create a sub-conversation
Does NOT preserve the exchange in history

Practical Use Cases

Use Case 1: Pre-Task Orientation

# Before starting a long task
/btw what's the typical pattern for handling authentication in Express.js?
# Get answer, dismiss with Escape
# Now start your actual task with context

Use Case 2: Mid-Task Quick Lookup

# In the middle of implementing a feature
/btw what does the retry logic do in this codebase?
# Get quick answer without adding to conversation
# Continue with your implementation

Use Case 3: Pattern Verification

# Quick sanity check
/btw is this the right way to handle async errors in TypeScript?
# Confirm approach without context pollution

/btw vs Normal Prompt: When to Use Each

# Using /btw (NOT preserved in history)
/btw what does the 'as const' assertion do in TypeScript?
# Answer in overlay, press Escape, history clean

# Using normal prompt (PRESERVED in history)
"What does the 'as const' assertion do in TypeScript?"
# Answer added to conversation history
# Claude will remember this for future context

Use /btw when:

Quick orientation questions before starting a task
“What’s the typical pattern for X?”
Quick concept lookups that don’t need persistence
Mid-task clarifications that aren’t part of the main work

Use normal prompts when:

The question relates directly to your current task
You want Claude to remember the answer for later
You need Claude to use tools (read files, run commands)
The exchange is part of the decision trail you want to preserve

Common Mistakes

Mistake 1: Expecting Two-Way Conversation

Users report confusion: “are you not allowed to talk back to it”

The answer: /btw is a one-shot lookup, not a dialogue. Ask your question, get your answer, dismiss.

Mistake 2: Expecting Tool Access

/btw cannot read files or run commands. It uses Claude’s knowledge + your session context only. For tool access, use normal prompts.

Mistake 3: Not Seeing the Difference

Users ask: “I didn’t see a difference with /btw”

The difference is invisible until you check your history. The value is in what’s NOT there - no context pollution.

Workflow Integration Example

# Scenario: Starting a complex feature implementation

# Step 1: Quick orientation with /btw
/btw what's the pattern for error handling in async functions in this project?

# Step 2: Dismiss overlay, start actual work
"I need to implement a new API endpoint for user notifications.
Please follow the error handling pattern used in src/api/users.ts..."

# Step 3: If you need another quick lookup mid-task
/btw what's the retry strategy for external API calls?
# Quick answer, dismiss, continue

Summary

In this post, I showed how to use Claude Code’s /btw command for quick lookups without polluting your conversation history. The key point is that /btw is a lightweight lookup tool that gives you answers without the overhead of a full conversation - use it for orientation questions, quick clarifications, and pattern lookups that don’t need to be part of your permanent decision trail.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

👨‍💻 Reddit: Claude just released /BTW and it's clutch
👨‍💻 Claude Code Documentation

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!