Every message you send an AI coding agent becomes part of its context - the working memory it carries through the session. Usually that is exactly what you want. It is how Claude Code still knows which file it edited twenty minutes ago, which approach you rejected, and what the last test run reported. The conversation is not just a transcript; it is the material the agent reasons from.

But not every question deserves to live there permanently. You are fifteen minutes into a refactor, the agent is working through a set of files, and you want to check something small. What was that config file called? What did the earlier error actually say? Which of those two functions did it keep? Ask in the main thread and you interrupt the work, and the tangent stays in the conversation for every turn that follows. Claude Code has a command built for exactly this situation.

What is a Side Question?

A side question is a question about the current session that never becomes part of the session. Claude answers it from what is already in the conversation - your messages, its replies, and the tool results it has gathered so far - and then the question and answer disappear. The main thread is left exactly as it was.

This matters because context is finite and shared. Everything in the conversation competes for the agent's attention on every subsequent turn. A thread cluttered with small lookups is a worse working environment than a focused one, even when each individual lookup was reasonable.

Using the /btw Command

The command takes your question directly:

/btw what was the name of that config file again?

In the terminal, the answer appears in a dismissible overlay above your prompt. In the VS Code extension it opens a panel instead, where you can ask follow-up questions in place. Either way the exchange never enters the conversation history. Example:

You can ask about anything already in the session - code Claude has read, decisions it explained earlier, output from a command it ran. A later side question also sees your earlier ones, so a short chain of related lookups still makes sense. Claude Code replays the most recent exchanges with each new ask, until you clear them.

Two limits define the command, and both are deliberate:

• It has no tools. A side question answers only from what is already in context. Claude cannot read a file, run a command, or search the web to answer it. If the information was never in the session, you will not get it.
• It gives a single response. There are no follow-up turns in the terminal overlay. To continue, you ask another side question.

These look like restrictions, but they are the design. A side question is not a second assistant - it is a read of memory the agent already holds. Keeping it toolless is what makes it fast, inexpensive, and safe to ignore from the main thread's point of view.

Asking Questions While Claude Is Working

This is the part that changes how you work. You can run /btw while Claude is still processing a response. The side question runs independently and does not interrupt the main turn. It sees everything in the conversation so far, except the reply Claude is still writing.

Before this, checking a detail mid-task meant either stopping the agent or waiting for it to finish. Now you can query the state of the session while the session carries on doing its job. On a long-running task, that difference adds up.

Side Questions or Subagents?

The distinction is worth holding onto: use a side question to ask about what Claude already knows from this session, and use a subagent to go and find out something new.

A side question has no tools, reads existing context, answers immediately, and leaves no trace. A subagent has full tool access, can investigate, and produces real work.

The two connect. From the overlay, pressing f forks that question and its answer into a background subagent which inherits the parent conversation and continues with full tool access. So the practical pattern is to ask cheaply first and escalate only when the answer is not already in the room ­- which is reasonable discipline well beyond this one command.

Working with the Overlay

Once the answer appears, the overlay accepts a small set of keys.

Your five most recent side questions appear as a dimmed list above the current answer. Running /btw with no question reopens the overlay on your most recent exchange. The thread lives in memory only and is gone when you exit Claude Code.

On cost, the documentation is straightforward: while the conversation's prompt cache is warm, a side question costs little beyond the answer itself.

Why Context Is Worth Protecting

/btw is a small command, but it encodes an idea worth internalising. When you work with an agent on real work, the quality of what it produces depends heavily on what sits in front of it. Context is a resource, and not everything deserves a place in it.

Most people never think about this, because they arrive from chat, where the transcript is the product. With an agent the transcript is the working memory, and the discipline of keeping it clean is part of using the tool well - in the same way that keeping a configuration file free of dead entries is part of operating a system well.

Conclusion

Side questions solve a small, specific, and genuinely common problem: needing to check something without paying for it in context or attention. Ask with /btw, read the answer, dismiss it, and the conversation continues untouched. When the answer is not already in the session, fork it into a subagent and let that one go looking.

It is a minor feature that quietly rewards a good habit - deciding, deliberately, what belongs in the agent's memory and what does not.

Relevant Training

Claude Code, permission modes, project context and memory are covered in detail in Agentic Application Development with Claude Code, part of the Claude AI learning program. This course is backed by fully integrated hands-on Cloud Labs, where you get your own temporary Google Cloud project to work in.