YT YouTube2Text

YouTube2Text → Transcripts → 5 Claude Cheat Codes Only The Top 1% Use

5 Claude Cheat Codes Only The Top 1% Use — Transcript

by Sean Kochel · 4,033 words · 587 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00In this video I'm breaking down five new
0:02Claude code commands that can help take
0:04you to the next level because most Vibe
0:05coders think they need complicated tools
0:09or mountain of skills in order to build
0:11something that they'd really be proud
0:13of, but the reality of the situation is
0:16you just need some simple tools executed
0:18really well. So I'm going to go through
0:20five of these commands, talk about why
0:22they're actually valuable, and obviously
0:24show you how to use them. We're going to
0:27start with the newest of the bunch,
0:29checkup.
0:30And so this command is again called
0:32checkup, also known as doctor. And one
0:36thing that I've always been kind of
0:37bewildered by is how people blow through
0:40like $200 per month Claude Max plans in
0:44like the first day of a reset. Then they
0:47go out there online and just like
0:48complain endlessly about it. And like
0:50that that is bewildering to me. And part
0:53of the reason that that happens is that
0:55when you're going out there and
0:56installing all of these different skills
0:58and MCP servers, those things are going
1:01to clog up your context window. So those
1:05things are going to be loaded in by
1:06default, especially if they are
1:08installed globally on your machine.
1:11They're going to get used and passed in
1:13every single chat. And that can take up
1:15a lot of space.
1:18And so what this command does is it
1:20helps us look at the like general setup
1:23of all of our different MCP servers,
1:25agent definitions, skills, plugins,
1:28globally installed packages, all of that
1:30stuff. And make sure that we're not like
1:33shooting ourselves in the foot before
1:35we've even gone out and launched
1:37anything.
1:38And so in our case this thing has run
1:39through and it's now done a checkup
1:41against like eight different parameters.
1:42So let's actually walk through and talk
1:44about them really quick. So the first
1:46one is just like general setup health.
1:48Health so like are is anything like
1:49actually straight up broken or do you
1:52have like dangling files like install
1:55files or configuration files somewhere?
1:57That's the first thing that it's going
1:58to look at. In our case, nothing to fix.
2:00Uh number two, unused extensions. So,
2:03are there things like plugins and things
2:05like that inside of the system that you
2:07have installed and they may be taking up
2:09context, but you don't actually use
2:12them. And so, these things can obviously
2:14be disabled like you are not using them.
2:16So, we can move through and cut those
2:17things out. Our Claude markdown file, I
2:20mean, this is one source of like a lot
2:21of waste from people. In this case, like
2:23one thing that I'm really big on on this
2:25channel, inside of my paid community,
2:27like anywhere's that if you really want
2:29to be good with this stuff, you have to
2:31be like militant about how you manage
2:32your Claude markdown files. And there's
2:35certain standards that you should
2:36conform to. So, like in in my case,
2:38there aren't any findings. Like our
2:40Claude markdown files are pretty pretty
2:42legit. Too legit to quit.
2:45And so, they're all under like these
2:46warning thresholds. The lines aren't too
2:47long. Like they're not contradicting
2:49each other. We're not like putting
2:50stupid stuff in there. So, all good to
2:52go on that side.
2:54And so, we're just continuing through.
2:55The The one thing, and this is going to
2:57be the big thing for like 90% of people
2:59that are watching this video, is the
3:01context check.
3:03The biggest issue that you are going to
3:05run into is going to be
3:09any like globally installed skills or
3:12plugins. That is going to be a big
3:14problem and we can see that in this case
3:16where roughly like 1% of the context
3:20budget should be
3:22dedicated to like your skills and your
3:24commands and like knowing what they're
3:26supposed be used for. And you can run
3:28into a lot of issues if that's not
3:30actually the case. And so, in this case,
3:33I've been developing a lot of skills
3:35locally on my machine, which is why I
3:37have a bunch of them. I do need to clean
3:38everything up. And so, we can see like
3:40we are beyond that. And again, that is
3:43going to cause problems for you
3:46because those definitions are going to
3:48get passed through to the model and then
3:50you're going to run into situations
3:51where skills are not being actually like
3:53used or routed properly and other
3:56commands can end up not being used
3:58properly.
3:59So, this is going to be like one of the
4:01biggest fixes. Now, the thing that I
4:02like about this skill is that it will
4:04help you clean everything up. Um I think
4:06they just made it so you can actually
4:07click on stuff. That's crazy. I don't
4:09think I've ever actually clicked on one
4:10of those things before. But anyway,
4:11hopefully I clicked on the first one.
4:13So, I like to use auto mode as a
4:15default. Wow, yeah, you can click on it
4:16now. That's crazy.
4:18My mind is blown. I didn't notice that.
4:20Um I'm always on my keyboard. So, I like
4:23to use auto mode for like everything
4:25now. So, we're doing things like setting
4:26auto auto mode to be the default, but
4:29generally we're just moving through and
4:30again running this like checkup {slash}
4:32doctor command to make sure that our
4:36general setup is good to go so that
4:39we're not just like repeatedly bashing
4:41our head against the wall with a bunch
4:42of errors that shouldn't even be there
4:44in the first place
4:45because that sucks. So, if you want a
4:47token max on a budget, so token
4:51optimize, I guess, you got to make sure
4:53that you're not just doing stuff that's
4:55completely stupid.
4:56Now, this checkup skill is actually a
4:58prerequisite for the next skill that we
5:01are going to look at.
5:03So, one of the big like unsung heroes, I
5:06would say, of the last few months,
5:07Claude has a version of this, OpenAI has
5:10a version of this, it's this goal
5:11command. And when you have this goal
5:13command, basically what happens is that
5:16you can give it a goal that it will
5:19continue to work toward, auto compacting
5:22along the way as it needs to, until it's
5:25actually complete.
5:27And so, this is really good when you
5:29have like a very large body of work that
5:31needs to be done and you have a
5:34verifiable end state, meaning you would
5:37know and you would be able to tell when
5:39that work is actually complete.
5:43And so, there's a few situations that
5:44they give here that are like examples of
5:47where that would make sense. For
5:49example, like doing major migrations and
5:51making sure that all of your tests pass,
5:53implementing a design doc until all of
5:56your acceptance criteria are valid,
5:59refactoring like very large files maybe
6:02into like very focused modules that are
6:04under a certain like size budget. My
6:07favorite personally, working through
6:09issue backlogs until a queue is empty.
6:13And this is the one that we're going to
6:14use as inspiration for what I want to
6:17show you.
6:19And so, one of the things I do whenever
6:20I want to like build a lot of features
6:22at once and have these things just like
6:23run autonomously, there's always this
6:26idea of the smoke test. Meaning, we need
6:30to be able to actually manually test the
6:34things that we allegedly just
6:36implemented. Like we need to be able to
6:38know that those things were implemented
6:40the way we needed them to be. And so, if
6:43we're trying to, for example, like do a
6:45major change or implement something that
6:47maybe it's like a few features needing
6:49to come together or even one larger
6:52feature, typically what you're going to
6:53have to do is after you run it and all
6:56the you know, the tests are working and
6:58all of that, especially if you're
6:59building with agents, by the way, you
7:01need to go through and actually make
7:04sure that the logic that you built is
7:07actually functioning because language
7:10models will often build tests for you
7:12that they are not actually testing
7:14anything meaningful and the test passes,
7:17but what you wanted it to do is not
7:19actually what's happening. And so, this
7:21concept is often called a a smoke test
7:23where, for example, in the context of
7:25like this
7:26um agent native like nutrition tracking
7:29app, if I was to say something like log
7:31my chicken bowl from last Tuesday, it
7:33should be able to go out like find that
7:35thing in my database and actually log it
7:37and then like plan my day based on the
7:39things that it found there, for example.
7:41And so, if a user was to come through
7:43and like type this in, there's different
7:46scenarios where different things should
7:49happen.
7:50And these are cases where like
7:52realistically, we would want to go
7:53through and test that all of these
7:55things are actually happening properly,
7:57right?
7:58So, for all of these different features,
8:00in this case, there's like a lot of
8:01different things that we've been
8:02implementing inside of Open Spec. All of
8:04these things are things that we would
8:06need to test manually. And so, we can
8:09actually automate this process with
8:11something like the goal command.
8:14And so, in this case, we could come
8:15through and we could do something like
8:16this. So, we could use the goal command,
8:19and then if we remember what it said
8:20needs to be the case is that we have
8:22like a verifiable
8:24exiting criteria. And so, we could say,
8:27"I want you to check every smoke test."
8:29So, thinking back to that file we were
8:30just looking at,
8:32"I want you to test every single one of
8:34those things using the iOS MCP." So,
8:37this is how we can actually control our
8:40simulator.
8:41So, I want you to check every single
8:43thing with that iOS MCP autonomously,
8:46and then I just want you to report the
8:48findings. So, I'm not asking it to
8:49actually go through and make the fixes.
8:51I just want it to go through and
8:53actually do each of the test elements.
8:56So, in this case, there were, I don't
8:58know, a dozen or two different items
8:59that need to be tested, and I want it to
9:01just go through, actually run these
9:03things,
9:04and then tell us what the result is.
9:06Like, that that's it. I'm not asking it
9:07to go through and then spend 50 hours
9:09trying to test every single thing and
9:11fix it and then retest it. You can do
9:14that type of stuff, but that's not what
9:16we're going to do in this example. Now,
9:17I'm telling you that the task this task
9:19is considered done when every single
9:23task list item in the smoke test has
9:25been tested, and the results have been
9:27documented. You should notate if it
9:28worked successfully or if there was a
9:30failure, and you should be
9:32cross-referencing the UI against the
9:34intent of the feature. So, this thing
9:35that we're testing specifically, this
9:37was like a major UI migration.
9:40>> [snorts]
9:40>> And so we want to make sure that like it
9:42it's actually functioning the way it
9:43should be. And in this case, just like
9:45save our contacts window, I'm saying
9:47that each of these phases in here, so
9:50like this phase so like this phase, this
9:53phase, this phase, they're all done via
9:55sub agents. Okay? So now I could run
9:58through and I could just kick this thing
9:59off. And now this is going to run
10:02autonomously in the background.
10:04Now the one thing as this thing starts
10:05to go that you obviously need to pay
10:08attention to is going to be your token
10:10usage. And my philosophy with this
10:13is that obviously it uses more tokens.
10:15Something like a loop or something like
10:16a goal is obviously going to use more
10:18tokens because it is it's always
10:20working, right? Assuming that the goal
10:23hasn't been met yet, it is going to
10:25continue to be doing things. So when
10:27people complain that things like goals
10:29and loops and workflows use more tokens,
10:32it's like well obviously, right? It's
10:34it's working all the time in the
10:36background. It's it's constantly moving.
10:38So obviously it's going to use more
10:39tokens.
10:41And so that's fine. We just need to be
10:43aware of the fact that this thing is
10:45going to be running and running and
10:46running.
10:48And we need to just accept in our minds
10:51that this is like replacing us having to
10:54be there doing all of the things
10:56manually. And how much that is worth to
10:58you is a it's a personal question,
11:01right? If you're on a a Claude Code Max
11:03plan and a Code X Max plan each on $200
11:07per month,
11:08I don't think there's any way in in hell
11:09that you could run out of tokens
11:12realistically doing these things unless
11:13you're just being like incredibly
11:15irresponsible about what you're doing.
11:17So like yes, this stuff will use more
11:18tokens, but it also allows you to go out
11:21and do other things.
11:24And so this task, this is obviously
11:25going to take maybe like one or two
11:27hours at least to run through everything
11:29and report back.
11:30So while this is out and running, we're
11:31going to talk about something else,
11:33which is well, how then do we actually
11:35keep track of all of the spending? So,
11:38this one's going to actually be a
11:39two-for-one. So, the first thing that
11:40I'm going to show you is it's a tool or
11:43a command that I've used for a long
11:45time, and I'm I'm always surprised when
11:46people haven't actually heard of it, and
11:49they're asking like, "Hey, how do you
11:50get that thing at the bottom that's
11:52telling you, you know, all of these
11:53tokens that you have used or what you
11:55have left?" So, if you come down and you
11:57type in status line,
12:00we can then come through and actually
12:01give it a command. So, for example, I'm
12:03going to run status line, and I'll have
12:05this exact command in the description
12:06below for you. We could say status line,
12:09I want to visualize the model in use,
12:13the directory, the work tree, current
12:17context window size,
12:195-hour, 7-day
12:22context usage limits.
12:25And so, what this command is going to do
12:27is it's going to actually set this up
12:29for you that you can see at the bottom,
12:32where we're able to actually see in real
12:34time
12:35how much of our stuff, you know, our
12:38context window like token allocations
12:40we're actually using, and like where we
12:43actually are inside of the system. So, I
12:44like to like keep a track on the model
12:46that I'm using, the specific branch that
12:49I'm on, making sure that I like I know
12:50I'm in the correct branch, and then I
12:52keep a laser focus on the exact size of
12:57my session that I'm working in right
12:59now. These two I typically don't really
13:02have to keep track of because I don't
13:03come anywhere close to them unless I'm
13:05using things like fable. That's the only
13:07time I think that I've I've
13:08realistically come close to like, "Oh, I
13:10need to pay attention to like my 7-day
13:12usage." And so, the the second command
13:14that we can run here is {slash} context.
13:17And so, this is going to give you a an
13:19understanding of the usage of your
13:22session. So, in this case, we can see as
13:25things grow, where is our usage actually
13:29going? So, if we think back to earlier
13:31with that doctor command and we are
13:33trying to think through like where are
13:35skills taking up too much of a budget
13:37and like where is our budget actually
13:39going? This is how we can visualize this
13:41and I think they built this because so
13:44many people were trying to build their
13:45own like open source libraries to help
13:47us
13:48handle this type of stuff that they just
13:50decided to do it themselves. And so, we
13:51can see like how much is going to our
13:53system prompt, the tools that we're
13:55using, custom agents, memory files,
13:57skills, the messages that we're sending,
14:00like where is our context actually being
14:03used? And so, between the status line
14:06and this context command, you get like
14:07two really powerful insights. Number
14:10one, in the course of my conversations,
14:13am I using tokens in a really stupid way
14:15that I'm not even aware of? And number
14:17two, am I losing the battle before it
14:20even starts? If you load this thing up
14:23and you're already at like a a ton
14:26of tokens being used,
14:28you have problems, right? You have way
14:30too many skills being loaded up. Maybe
14:33have way too many like agent
14:34definitions,
14:36memory files, things that are just
14:37consuming tokens potentially for no
14:40reason at all. And that is a huge waste.
14:43And so, if we were to pop back into that
14:44gold chat, this thing is still running,
14:46right? So, it's still out there. It is
14:48interacting automatically with this
14:49simulator, testing all of the things,
14:52logging exactly what is happening,
14:54interacting with it. It's really
14:56awesome.
14:57But now, this can also create like a
14:59different problem for us. And so, if
15:00we're doing all of this stuff in like
15:03three, four, sometimes like five
15:04different agent sessions all at once,
15:07and then you need to like step away and
15:09go somewhere,
15:10that can create a big problem
15:13for a few different reasons and I don't
15:15want to go deep into the philosophical
15:16rabbit hole, but human beings have a a
15:19really hard time managing cognitive load
15:22when there's a ton of open loops. So, if
15:24you've opened up like five of these
15:25things and then you have to go
15:28somewhere, you've now just generated a
15:30ton of context that hasn't necessarily
15:33been addressed. It hasn't necessarily
15:35been tied off and it can be very
15:37difficult to load back up on that
15:41context when you step back to your
15:43computer. And so, this next command can
15:46actually help us manage a bit of that
15:48cognitive load.
15:50So, let's say for example, like I called
15:51it quits last night at 8:00 p.m. and now
15:53I'm coming back to my machine in the
15:55morning and I have like a bunch of these
15:56different terminal windows, right all
15:57across here and I'm working on a bunch
15:59of different stuff. I'm working on like
16:01automated topic sourcing systems for my
16:03social media stuff. I'm building like
16:05workflows that can just generate things
16:07autonomously all by themselves,
16:09which is, yes, redundant to say.
16:12I'm debugging a bunch of other skills
16:15that I have. Like I have like three,
16:16four, five different things going on at
16:18the same time.
16:20And now I want to come in and check on
16:21like, what dude, what was I like
16:23actually working on here yesterday? What
16:26I can do is I can come through here now
16:28and I can type in recap.
16:31And so, what this is going to do is this
16:32is going to generate like a one-line
16:36recap of exactly what you were working
16:39on in this project.
16:41So, in my case, I have this project
16:42called Topic Genie and what were we
16:44doing? I was trying to import my last
16:47year of videos and the different
16:49outliers for my channel.
16:52And then I wanted to add in a reminder
16:53to me every week when I run this that I
16:55need to update it with new data from
16:57both myself and my competitors. And so,
16:59it went through and it built everything
17:01and the next action is mine. So, there's
17:03nothing much to do here.
17:05That one is good to go. And so, this is
17:06really important because you absolutely
17:08will build a habit of half building
17:11things and like never getting things
17:13truly to the finish line because you're
17:15constantly getting this like whiplash
17:17between a growing pile of half-done
17:20stuff.
17:21And that's bad for like very obvious
17:23reasons. And so a command like this
17:25helps us rein that type of stuff in. And
17:28so the last thing I want to show you is
17:29a command that I I also really really
17:32really appreciate. Like when you need
17:34it, it's awesome. And that command is
17:36called by the way. So if you were to
17:38come down here and you were to type in
17:40w, this allows you to have a quick like
17:42side conversation with the model without
17:46flooding that context into this main
17:49window. So right here, this goal thing
17:51is still running through and like
17:52testing our app. So if we were to pop
17:54over here again, it's searching through
17:56the library. It's trying to interact.
17:58It's like it's doing all of that stuff.
18:00But I might be on a train of thought
18:02where like I want to have a conversation
18:04or ask something about this. But I
18:08again, I don't want to interrupt that
18:09main process. So we can use this
18:11by the way command to get something off
18:14our chest. So an example of this in the
18:16context of this project, uh the way that
18:18this like model like agent loop is
18:20working since this is a a mobile app and
18:22we don't have like a server necessarily
18:24on the back end is that we're using
18:26Superbase's edge functions to call the
18:28language model APIs and like run this
18:30loop that we have. And so something that
18:33I'm I'm thinking of as this is going is
18:35like did we actually like modify those
18:38functions properly and because we like
18:39changed a few of like the inner workings
18:41of things, I want to make sure that
18:42that's the case. And so we can come down
18:43and we could type in by the way and then
18:45we could ask it some sort of uh
18:47question.
18:48So we might ask something and we could
18:50use like a really basic example, where
18:52are all of the reports being output to?
18:56And so now we can see we have this
18:57directory called smoke results. And now
18:59the reason I wanted to show this to you
19:01is that we have this option to actually
19:03fork the chat. So if we were to type in
19:05F in here,
19:07we can now actually like continue this
19:09conversation
19:11from this specific point. So, this is
19:14almost like we've now forked off a
19:15completely different chat where we can
19:18now basically operate within our own
19:20sub-agent to continue this line of
19:22reasoning.
19:24So, an example here might be something
19:25like start prioritizing and
19:28investigating root causes of everything
19:32that's failed so far. Now again, this is
19:35going to happen inside of a sub-agent.
19:37It's going to go out. It's going to
19:38start responding to like whatever this
19:40command was, and then we still have all
19:43of like our main work being done with
19:44the actual like testing taking place
19:47inside of that main thread. So, I really
19:49love this like by the way and forking
19:52functionality so that you can like
19:54interject when you need to, and then if
19:57for whatever reason like you want to
19:58continue down that thread right now, you
20:01can do that here, and you're not going
20:02to again like just get lost in the
20:04context of everything that is happening.
20:07So, collecting like tools and knowledge
20:08like this like can be valuable, but it
20:10doesn't really mean anything if you're
20:11not like deploying it into building
20:14things that actually work
20:16that you either use for yourself, you
20:18use in the workplace, you're packaging
20:20it into like an app or SaaS, and you're
20:22trying to sell it. Don't be the guy that
20:23just lets skills grow dusty on a shelf.
20:26So, if you want help with implementing
20:28any of that stuff, you can check out the
20:29links in the description below, but that
20:31is it for this video. I will see you in
20:33the next one.

About this transcript

This page contains the full transcript of 5 Claude Cheat Codes Only The Top 1% Use by Sean Kochel, generated from the public captions YouTube serves with the video. The transcript has 4,033 words across 587 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to translate the transcript into 100+ languages.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, translation to 100+ languages, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.