Navigating Claude Code Without the Noise
We've all been there. You start with a clear task, then ask a quick question, then another. Soon the session fills with side conversations. The system slows down, forgets instructions and starts making avoidable mistakes.
This is the cost of context pollution. Every interruption adds noise. Not just tokens, but confusion. A focused agent, like a focused person, depends on continuity. Break that and you lose momentum.
We’ve all been guilty of this at some point. We get busy in the trenches. Too many tasks get mixed together and we don’t realise the goal starts slipping. Then comes endless correction, fixing the same mistake again and again instead of resetting.
/btw is a Whisper, not a Command
The most useful change I've seen is simple: a side-channel. /btw lets you ask a question without polluting the main thread. It shows up as a temporary overlay and doesn't get added to working memory.
That changes how you work. Instead of interrupting the task, you step alongside it. You can ask why something is happening, what a decision means or whether there's a better option, then return straight to execution.
No reset. No context buildup. No drift. The system keeps working while you keep learning.
The Difference Is Momentum
Without a side-channel, every question becomes a trade-off. You either stop the task or accept degraded performance. With /btw you don't have to choose.
The main thread stays clean and the agent keeps moving. There is a constraint: /btw has no tool access. It won't read files or change code. That's intentional.
If you need action, use the main thread. If you need understanding, stay out of it. Mixing the two is where most problems begin.
Steering Beats Restarting
We still tend to work in cycles. You prompt, wait, evaluate, then try again. It works, but it’s slow.
A better approach is to steer while things are running. If you notice the output is off, don't stop everything. Adjust direction.
Small corrections, applied early, prevent larger corrections later. Only restart when the task itself has changed. That distinction matters.
Know When to Stop
There's a point where steering stops working. You've corrected twice, maybe more and the system still drifts. That's stale context.
Adding more instructions won’t fix it. It usually makes things worse. This is where time gets wasted, arguing instead of resetting.
The better move is to go back to when things still made sense and start again with a clearer prompt. It feels slower, but it isn't.
Keep Exploration Separate
Not everything belongs in the main thread. Sometimes you need to try something, read more or explore an idea. Start a parallel session.
Don't overload the execution path with experiments. Keep that path focused. Execution and exploration are both useful. They just shouldn't happen in the same place.
A Simple Working Model
I keep it basic. One thread, one goal. Use /btw to ask without interrupting. Steer when direction changes and reset when the task breaks.
Keep exploration separate from execution. Clear context between unrelated work. That's enough.
Most improvements don't come from better prompts. They come from cleaner workflows. Less noise, more momentum, better outcomes.