5 Hidden Claude Commands That Will Blow Your Mind

I’ve been using Claude Code almost every day for months now, and the funny thing is, most of the stuff that actually saved me time isn’t in any tutorial. It’s the small commands nobody bothers to mention. You find them by accident, or somebody drops one in a comment, and suddenly you’re wondering how you worked without it.

None of these are fancy. That’s kind of the point. They’re not going to write your whole app for you. They just fix the little annoyances that pile up when you’re deep in a session, the kind of friction you stop noticing because you assume that’s just how it works.

So I put together the five I keep coming back to. A couple of them I now use without even thinking. Let’s go through them.

1. /btw

This one is for the moment you’re mid-task and you suddenly remember something you should’ve told Claude earlier.

Normally people just stop, type a big new message, and kind of restart their train of thought. /btw lets you drop that little "oh by the way" note into the conversation without derailing whatever Claude is already doing. You add the context, Claude picks it up, and the work keeps moving.

Sounds tiny, I know. But once you get used to feeding Claude small corrections as they come to you instead of holding them all till the end, the back-and-forth gets a lot smoother.

Why it’s useful: most bad outputs come from Claude missing one piece of context you forgot to mention. This is the fastest way to hand it over the second it pops into your head.

2. The ! command

This is the one I tell everyone about.

Say you’re inside Claude and you just want to run a normal terminal command. Maybe a git thing, maybe you want to check a folder, maybe run a quick script. You don't want to explain it to Claude, you just want it done. Put a ! in front and Claude Code runs it straight in your shell, like a normal terminal would.

So basically your Claude window turns into a regular terminal whenever you need it to. No switching tabs, no opening a second window. You stay in one place.

I use this constantly for git. !git status, !git diff, quick stuff like that, without breaking my flow to go somewhere else.

Why it’s useful: you stop tab-hopping between Claude and your terminal. One window does both, and the command output stays right there in the conversation where Claude can see it too.

3. Double Escape

Okay, this one saved me more than once.

You know that feeling when Claude goes off and makes a bunch of changes, and you look at it and think, no, that’s not what I wanted at all? Instead of trying to explain a fix, or manually undoing everything, just press the Escape key twice.

It takes you back and lets you rewind the conversation to an earlier point, before those changes happened. It’s basically an undo button for the whole direction the session took, not just one file.

The first time I found this by accident I actually laughed, because I’d spent weeks awkwardly telling Claude “no, go back, remove that” like it could read my mind.

Why it’s useful: when a session goes sideways, you don’t argue your way out of it. You just jump back to the last good moment and try again with a cleaner instruction.

4. /context

This is the boring-sounding one that turned out to be really practical.

Type /context and Claude shows you how much of its memory, the context window, you've actually used up in the current session. You get a clear picture of what's taking up space and how much room is left before things start getting fuzzy.

Why do you care? Because long sessions quietly fill up. And when the context gets too full, Claude starts forgetting stuff you told it earlier, or the answers get a little worse and you can’t figure out why. /context tells you exactly where you stand instead of guessing.

I check it whenever a long chat starts feeling off. Nine times out of ten, that’s the reason.

Why it’s useful: it takes an invisible problem, running out of context, and makes it something you can actually see and plan around. Great time to start a fresh session before quality drops.

5. /fork

Last one, and it’s the one I wish I’d known about sooner.

Sometimes you’re in a really good conversation, everything’s set up nicely, and you want to try something risky without wrecking what you’ve got. /fork lets you branch off from where you are. You get a copy to experiment in, while the original stays exactly as it was.

Think of it like saving your game before a hard level. If the experiment works, great. If it blows up, you just go back to the version that was fine.

I use it a lot when I’m not sure about an approach. Fork it, test the idea on the copy, and I never have to worry about messing up a session I spent an hour getting right.

Why it’s useful: you can be bold and try weird ideas without the fear of losing good work. That fear is what makes most people play it safe and get boring results.

That’s the five. None of them are secret exactly, they’re just quiet, and quiet things are easy to miss.

If you only take one from this list, make it the ! command. It's the one that changed my day-to-day the most. But do yourself a favor and try all five in your next session. Give each one a real shot, not just a read. The whole point of these is that you don't feel the difference until you've actually used them a few times.

And if you find one I missed, drop it in the comments. That’s how I found half of these anyway.

Thanks for Reading :)