Anthropic just dropped one of the most

useful features in Claude Code ever.

It's called /btw. It saves you twice the

tokens and allows you to do things in

half the time, and I don't really think

a lot of people know about it. Now,

previously, if I was having a

conversation with Claude Code, let's say

I asked it to scrape a thousand paper

click agency owner leads and then give

them to me in a Google Sheet. If I

wanted to ask a question to Claude Code

in the middle of this, it might have

been related to the skill, to the

context that we just loaded in our token

window. Well, the only way for me to do

this would have literally been to open

up another Claude Code thread, ask it a

question, tell me about scrape leads,

and then have it go on its way. The

issue with that, obviously, is every

time you load a new instance of Claude

Code, you're consuming a tremendous

number of tokens that aren't actually

related to the work that you're doing.

You basically have like a fixed 10 to

20,000 token cost every single time you

open a new window, and there was no way

not to consume that. Well, that's where

/btw comes in handy. Now, I could tell

it to scrape 1,000 PPC agency owner

leads, but if halfway through I have

either a follow-up question about this,

or maybe I wanted to give it to me in a

CSV, all I need to do is type /btw,

and then write what I want to say. So,

sorry, I meant a CSV. This will

dynamically open a new window called the

/btw window, that allows us to insert

information through the conversation

chain without actually interrupting the

thread. I can also ask it questions

about, let's say, the specific skill,

taking advantage of a lot of the

functionality and features here. So, I

could say, /btw,

tell me how this skill works. While it's

currently working on the skill, it will

also go through the skill documentation,

and then instead of forcing me to reload

all of my tokens, now it's giving me a

context and information in this little

answering thread. And you can see it's

actually doing that while it's also

debugging the rest of everything up

above. So, based on what I've read so

far, here's how all of it works. This is

a window that doesn't close as the

context continues to pump above here,

and so it's also just a lot more

convenient cuz now we have this little

side window we can have a conversation

with it without necessarily needing like

20 parallel instances. So, this is a big

deal. Previously, before /btw, you know,

I was spending significantly more in

token costs. Anytime I wanted to ask a

question that was related to the context

of the first thread, but maybe didn't

want to interrupt that main thread, I

had to open up a whole new Claude Code

session, and then in that Claude Code

session say something like, "Hey, go

find me the conversation context from,

you know, the conversation I was just

having on X, Y, and Z." We have to

refine assets, we have to split our

context. This is a tremendous amount of

work that basically we need to do,

you know, in order to get that done.

But, with BTW, now we can actually have

the main conversation window up here,

and then have a little side conversation

down here without actually having to

like parallelize, without actually

having to, you know, switch our our our

contexts, and then start multitasking,

and so on and so forth. So, it's way

cheaper. You have everything in a

unified context window just in one

thread, so the quality of the responses

probably goes up. In terms of how this

works, it's about as simple as possible.

You just type /btw.

You have to be in a terminal version of

Claude Code as of the time of this

video, but I bet you that's going to

change. You then give it the request in

the same message, so don't just type

/btw, and then press enter. That's not

going to work. You have to type /btw

space whatever the heck you want. That's

going to open up this little side panel

here with the /btw in yellow, and then

you sort of have three options. You can

read through this, and then press space,

enter, or escape to dismiss. When you do

this, I'm going to press space over

here, you'll just snap right back to the

main thread, and that'll open you up to

ask other questions. What's going on

with these, I don't know, errors, for

instance. That'll allow Claude to

actually answer me without me actually

having to pause this every 5 seconds. I

can actually gain context while things

are going on. If you don't currently

have this, it's pretty simple and

straightforward to get. Make sure on the

top left-hand corner of your

anti-gravity Visual Studio Code

instance, you open the extension, click

on the settings. If you don't already

have access to this, it's probably

because your Cloud Code either extension

or maybe your Cloud Code for desktop

functionality is not updated. So, make

sure that auto update is on. If you have

a specific issue with this, you can

actually go click install specific

version, and then you can update to the

main version here, which is 2.1.73

in this case 36 minutes ago. Um you

know, you can also just uninstall Cloud

Code if you're using the VS Code

extension, and then reinstall it. That

usually works fine. Once you're done

with that, head over to settings,

and then at the very bottom here, you're

going to always want to have use

terminal on. Otherwise, you're going to

have to manually go into Cloud's GUI,

and then type {slash} terminal, which

while possible is just kind of annoying

to do, and it usually takes a fair

amount of time.

Just because of how Cloud Code works and

the fact that the terminal version was

first, they usually develop the new

features for terminal, despite the fact

you might have seen me use the GUI in

other videos. I do that more for

simplicity, not for cutting-edge

features. So, definitely take a look at

that. That'll open up this new terminal

thing, and then you can say, "Hey,

what's up?" And while it's answering,

you can ask something else as well.

Hopefully, that clarifies things, and

you guys now know everything you need to

know to crush the {slash} BTW feature,

change your workflow, take advantage of

both the inbuilt parallelization and the

reduced token costs, and have a lovely

rest of your day.