Small features can change workflows massively — and the new /btw is definitely one of such.
❌ Before:
This is what many of us are used to right now — every question you ask an AI coding assistant becomes part of the same growing conversation thread:
No /btw feature used to ask questions here 👇:
Which unfortunately leads to questions, clarifications, and quick reminders slowly cluttering the context — making sessions more expensive than ever.
✅ Now:
Now Claude Code’s new /btw command is here to change all that — by creating a lightweight lane for disposable, context-aware questions.
Making changes just before using /btw:
Asking questions on our changes with /btw:
When we press Enter, the btw message disappears and we’re back to our normal conversation:
It’s a simple but powerful feature that makes those long coding sessions cleaner and much more efficient.
What /btw actually is
/btw is a lightweight side-question feature inside Claude Code. It can see the current session context, meaning it understands the code, decisions, and task state already in play.
But unlike the main thread, it’s intentionally constrained.
1. Context-aware
/btw understands the active session.
That means you can ask questions tied to the current work, such as:
Making changes to our codebase:
- “What does this regex do?”
- “What is this helper function responsible for again?”
- “Why did we choose this configuration pattern earlier?”
Using /btw to ask context-aware questions:
You’re not asking a model with zero memory. You’re asking from inside the active coding session, where the relevant context already exists.
That’s what makes /btw more useful than opening a separate AI chat.
2. Disposable history
The core idea behind /btw is that the interaction is temporary.
Your question and its answer do not become part of the main conversation history.
Making changes to our codebase:
Why this matters:
Many developer questions are momentary:
- reminders
- clarifications
- quick explanations
Using /btw to ask questions:
Claude Code doesn’t remember the previous /btw message:
You need the answer right now, but the agent doesn’t need to keep re-reading that exchange for the rest of the session.
Think of /btw as:
- a sticky note, not a commit message
- a side whisper, not a meeting transcript
3. Read-only
Another important constraint:
/btw cannot perform actions.
Making changes to our codebase:
It cannot:
- edit files
- run bash commands
- use MCP tools
- inspect new files
It can only talk.
Trying to make changes with /btw — it doesn’t work — it only shows a message containing the code at best:
This means /btw isn’t meant for implementation work. Instead, it’s meant for:
- explanations
- reminders
- quick clarifications
- contextual understanding
You use /btw to stay oriented while real work continues elsewhere.
4. Single-turn only
/btw also enforces a strict interaction model:
One question. One answer.
There’s no extended back-and-forth and no mini-thread forming inside the /btw window.
That constraint prevents it from turning into a secondary conversation.
It stays exactly what it’s meant to be: a quick aside.
How it helps us as developers
The real value of /btw isn’t the command itself.
It’s how it improves workflow during long, context-heavy coding sessions.
1. Massive token savings
Claude Code stays effective by remaining aware of the full conversation history.
But that also means every new turn in the main thread carries the cost of everything that came before it.
As sessions grow, small interruptions become expensive.
For example:
- A 40-message thread means Claude rereads a large context every turn.
- Adding clarification questions increases that cost quickly.
This is where /btw helps.
Instead of putting these into the main thread:
- “What does this regex do?”
- “What was this utility function for again?”
- “What does this flag change?”
You route them through /btw.
The result:
- fewer tokens in the main thread
- less history to reread
- significantly cheaper long sessions
Over time, this can cut total session costs dramatically.
2. It prevents context rot
Long AI conversations naturally degrade.
As threads grow, the context becomes noisy:
- temporary explanations
- side questions
- dead-end ideas
- minor clarifications
Eventually the model starts losing track of what matters.
Developers often see this as:
- missed constraints
- forgotten earlier decisions
- weaker reasoning
This is essentially context rot.
/btw helps prevent this by enforcing separation:
Main thread
- implementation
- architecture decisions
- debugging
- planning
- file edits
/btw
- explanations
- quick reminders
- clarifications
- trivia
Keeping those categories separate helps the main thread remain clean and focused, which maintains higher reasoning quality for longer.
3. Seamless multitasking
This is the most underrated benefit.
During long-running Claude tasks—like refactors or multi-file updates—you’ll often have small questions.
For example:
- “What syntax does this function expect again?”
- “What does that pattern mean?”
- “Did we say this utility handles validation?”
Without /btw, you have two options:
- Interrupt the main thread and risk derailing the workflow.
- Hold the question in your head and slow yourself down.
/btw gives you a third option.
You can quickly ask the question without altering the agent’s working context.
This makes Claude feel less like a fragile chat log and more like a collaborator that can handle quick side questions while staying focused on the main task.
The real takeaway
The best way to think about /btw is this:
It’s a pressure-release valve for long Claude Code sessions.
It allows developers to:
- ask context-aware questions
- avoid polluting the main thread
- reduce token usage
- preserve reasoning quality
- multitask more smoothly
For developer workflows, that’s not a flashy feature.
It’s just good interface design.
Most AI tools treat every interaction as permanent. /btw recognizes that real development doesn’t work that way.
Some questions matter long-term — others are just momentary.
Treating those differently is exactly why /btw matters.