15 Claude Code Tricks That Feel Like Cheating

**SPEAKER_1** (0:00)
Welcome. Today, we're discussing an interesting content about a set of powerful insider rules for mastering Claude code, straight from its creator. Let's dive in.

**SPEAKER_2** (0:12)
I'm so excited for this. These aren't just theoretical best practices. This is what the creator actually does.

**SPEAKER_1** (0:19)
Exactly. So let's start with what he called one of the highest impact things you can do.
Using Chrome for verification. What's that about?

**SPEAKER_2** (0:29)
It's genius in its simplicity. Think about it. Would you ask a human to build a website without letting them see the website in a browser? Of course not.

**SPEAKER_1** (0:38)
That makes so much sense. So you give the AI access to a browser, and it can literally see what it's building and iterate until it looks right.

**SPEAKER_2** (0:47)
Precisely. You just kick it off with a simple dash-dash Chrome command. It can then take a clunky modal, for example, and refactor it into a proper settings page, testing its own changes in the live browser until it's perfect.

**SPEAKER_1** (1:00)
Wow.

**SPEAKER_3** (1:01)
Okay.

**SPEAKER_1** (1:02)
Next up is something I am definitely guilty of not knowing.

**SPEAKER_3** (1:06)
Forking a conversation.

**SPEAKER_1** (1:08)
I've always just muddied up my context trying to explore different ideas.

**SPEAKER_2** (1:12)
You and me both, but it's built right in. The slash branch command is a game changer. It creates a fork in the road. You can go explore a wild idea, consume all the tokens you want, and then...

**SPEAKER_1** (1:24)
And then you can just jump back to the original clean context?

**SPEAKER_2** (1:28)
Instantly. You just use slash resume with the ID it gives you, and you're right back where you started. Totally unspoiled. It's a massive workflow improvement.

**SPEAKER_1** (1:38)
My mind is blown. Okay, so now we've got these clean conversation branches, but what if I get a brilliant idea when I'm away from my main computer?

**SPEAKER_2** (1:48)
He's got a two-for-one solution for that. Remote control and teleport.
If you type slash remote control on your desktop, that exact session becomes available on your Claude mobile app.

**SPEAKER_1** (1:59)
No way. So I can pick up right where I left off on my phone? Yep.

**SPEAKER_2** (2:04)
And the other way works too.
Let's say you start something on the web or your phone. When you get back to your main machine, you just type slash teleport, select that session, and boom, the entire context is now on your desktop, ready to go.

**SPEAKER_1** (2:17)
That creates this amazing triangle workflow between desktop, mobile, and web. That's incredibly powerful.

**SPEAKER_3** (2:25)
But speaking of complex workflows, how do you handle working on multiple big things at once?

**SPEAKER_1** (2:30)
The creator apparently uses something called Git work trees?

**SPEAKER_2** (2:34)
He uses them extensively. The problem with just using Git branches is that you're working in one directory. If you're building a new feature, fixing bugs, and improving performance all at once, you'd be constantly committing, stashing, and switching branches. It's a nightmare.

**SPEAKER_3** (2:50)
I feel that pain.

**SPEAKER_1** (2:52)
It gets messy so fast.

**SPEAKER_2** (2:54)
With work trees, you spin up a separate directory for each task. Each one has its own Claude code instance running in parallel. No more context switching, no more overriding each other's work. Everything happens simultaneously.

**SPEAKER_3** (3:08)
Okay, that's a pro level tip.

**SPEAKER_1** (3:10)
Now here's one that surprised me.

**SPEAKER_3** (3:12)
He says to use Opus for everything.

**SPEAKER_1** (3:15)
I thought the standard advice was to plan with Opus and then implement with the faster, cheaper Sonnet.

**SPEAKER_2** (3:21)
That is the common wisdom, but his logic is fascinating. He argues that while Opus might be slower and more expensive per token, if it arrives at the correct solution faster, it's often cheaper and quicker in the long run.

**SPEAKER_1** (3:35)
So fewer mistakes and less iteration means you save time and money overall, even with the more powerful model. That's a bit counterintuitive, but it makes a lot of sense.

**SPEAKER_2** (3:46)
It really does. You're paying for quality and getting to the final result with less back and forth.

**SPEAKER_1** (3:52)
Got it. Now, let's talk automation. I heard about something called PR loops, automating pull request fixes.

**SPEAKER_2** (4:00)
Oh, this is brilliant. Imagine you push some code and a continuous integration check fails, say a simple linting error. Instead of you manually fixing it, he has a process that checks the PR every five minutes.

**SPEAKER_1** (4:13)
And Claude code just jumps in and fixes it?

**SPEAKER_2** (4:16)
It sees the failure, diagnoses the problem from the logs, fixes the code, commits the change, and pushes it. It just keeps looping until the PR checks are all green. It's like having a tireless junior dev cleaning up after you.