0:01 So, I figured out how to turn Claude
0:03 Code into the best business partner I
0:05 could ask for. And I made three times
0:07 more money in the past 30 days. You see,
0:08 Claude has these problems that a lot of
0:10 people don't ever notice. And every one
0:12 of those is costing you time and money
0:14 on stuff that's never going to work. So,
0:15 what I did is I built a set of four
0:17 upgrades to fix every one of those
0:19 issues. So, these four upgrades turn
0:20 Claude into something that actually
0:22 makes you money instead of just wasting
0:23 your time. And it doesn't matter if
0:24 you're trying to build an app or you're
0:26 running an agency or you're doing AI
0:27 consulting. This works for anything that
0:29 you want to do inside of Claude code.
0:30 So, in this video, I'm going to show you
0:32 guys the four upgrades and exactly how
0:34 you can use them to make more money. So,
0:35 let's get into it. Claude has a few
0:37 habits that quietly work against what
0:39 you're trying to do. Little things that
0:40 you might not think twice about. So,
0:42 think about how most people use Claude.
0:43 You open it up, you type what you want,
0:45 you get an answer, and you just kind of
0:46 assume that that is the best possible
0:47 answer that you could have gotten
0:48 because, you know, Claude code is one of
0:50 the best AI tools out there, and the
0:52 models underneath it, like Opus, are
0:54 super super smart. So, it's very easy to
0:55 just trust what it says. But there are
0:57 these errors that are baked into
0:58 Claude's design that make your results
1:00 worse than they should be. So by
1:01 default, Claude is tuned to make you
1:04 feel productive. It is not tuned to make
1:05 you money. And these are two completely
1:07 different things. And every one of those
1:09 design errors is costing you money
1:10 because your income is basically capped
1:12 by two things. The first one is the
1:13 quality of your output. And the second
1:15 one is how fast you can produce it. So
1:16 the better the output you get and the
1:18 faster you get it, the more money you
1:19 can make. I'm sure we can all think of
1:21 many specific moments where it felt like
1:22 Claude was just trying to get us to
1:24 spend more tokens or was lying to us
1:25 about features that it had built or you
1:26 know you feel like you're just repeating
1:28 yourself a ton. But the good news is you
1:30 don't need to go rewrite Claude's
1:32 codebase to fix any of these things. You
1:33 literally just need these four upgrades.
1:35 And before I started using these, I
1:36 remember launching promotions that did
1:38 not do very well at all or shipping
1:40 automations that were silently failing
1:41 or pushing out websites or apps with a
1:43 ton of bugs. So that's basically the
1:44 whole arc. But before we get into the
1:45 first upgrade, if you want to get these
1:47 prompts and skills and see how your
1:48 results get better, then you can get
1:50 them for completely free inside of my
1:52 free school community. The link for that
1:53 is in the description. Okay, so the
1:55 first upgrade fixes the biggest one,
1:56 which is just Claude agreeing with
1:58 everything you say. I mean, haven't you
1:59 guys ever noticed that you tell Claude
2:01 you want to do something and it pretty
2:02 much will always say like, "Hey, that's
2:03 a great idea. You're really smart."
2:05 Because it wants you to like it. But
2:07 then what actually happens if you say
2:08 like, "You know what? I changed my
2:09 mind." It will once again come back and
2:10 say, "You know what? You're really
2:12 smart. I'm glad you changed your mind.
2:13 That's a great idea and it's getting
2:15 better over time as the models are just
2:16 getting smarter and smarter. But this is
2:18 actually documented. Researchers call it
2:20 sycopant which is just a fancy word for
2:22 AI being a yes man. There's a study also
2:24 called elephant which measures exactly
2:26 this. And they found that AI models fail
2:28 to push back on the way you frame
2:30 something about 88% of the time and for
2:32 humans it's around 60%. And it actually
2:34 gets worse the more the model knows
2:36 about you. Researchers at MIT and Penn
2:37 State found that the personalization and
2:39 memory features tend to make the model
2:41 more agreeable over a long conversation.
2:42 And so that's tough because basically
2:44 the longer you work with it and the more
2:46 you use it, which is what we all really
2:47 should be trying to do, the better it
2:48 gets at telling you what you want to
2:50 hear. So this is a pretty simple fix.
2:52 You ask Claude to start challenging you
2:54 and pushing back and playing devil's
2:55 advocate before it builds anything or
2:56 before it approves any plan. And that's
2:58 the whole idea behind a skill that I
3:00 built called roast. It basically pulls
3:01 Claude out of agreement mode and it
3:03 forces it to stress test your idea and
3:05 its own work instead of just approving
3:07 everything. So basically what roast does
3:09 is it spins up a whole council of
3:10 personas and they attack it from
3:11 different angles. You've got a
3:13 contrarian whose only job is to find
3:15 fatal flaws. We've got an expansionist
3:16 who's looking for the biggest upside.
3:17 We've got a first principles thinker
3:19 who's working with no outside context,
3:21 just pure logic. We've got a deep
3:22 researcher that actually goes in and
3:24 pulls out a bunch of real market data
3:26 and competitor pricing off the web. And
3:28 then we have the buyer who actually role
3:29 plays being your customer and tells you
3:31 straight up if they buy the thing or
3:32 not. And then finally, the judge takes
3:34 all of those findings and gives you one
3:36 verdict. you basically get green light,
3:38 reshape, or kill. And it also gives you
3:39 the single cheapest test that you can
3:41 run in the next 48 hours to find out if
3:43 the idea is even worth pursuing, even if
3:45 it was reshaped. And so what I'm going
3:46 to do is throughout this whole video,
3:47 I'm basically just going to build a
3:48 little business from start to finish. So
3:50 you can see each upgrade working on
3:52 something real. So the idea that I want
3:54 to build out is a $9 a month tool that
3:56 turns a YouTube transcript into a week
3:58 of LinkedIn posts. So let me actually
4:00 just go open up Cloud Code and roast it
4:02 live. All right, so here we are right
4:04 now in a fresh Cloud Code project. You
4:05 can see right here, all we have is a
4:07 cloud.mmd, which basically has like
4:09 nothing in it. I just told it that your
4:10 job here is to help us make some money.
4:13 And then we have our claude with a skill
4:14 in here. And this is the roast skill
4:16 that I was just telling you guys about.
4:18 So, all I'm going to do is do a / roast
4:21 and say, I have this idea to make a $9 a
4:23 month tool where people drop in a
4:25 YouTube video link and that transcript
4:27 gets turned into a week's worth of
4:28 LinkedIn posts. So, I'm going to go
4:31 shoot off that message. So, as you can
4:32 see here, before it runs the council, it
4:35 has three quick questions to ask us. So,
4:36 the first thing is, who's the actual
4:39 target buyer for this $9 a month tool?
4:40 And let's just keep this as broad as
4:42 possible for now and really see what the
4:43 council can do. I'm going to say anyone
4:45 with a YouTube link. What is your edge
4:46 here? What do you already have? Let's
4:48 just say that we have, you know, no real
4:50 edge. We have no distribution, but we
4:51 can build something fast with cloud
4:53 code. And we'll shoot that off. And
4:54 then, what are our constraints and
4:56 budget? How fast do you need to get the
4:59 first dollar? Let's just say we have um
5:00 a little bit of runway, but not too
5:02 much. So, we'll shoot off those answers.
5:04 And now we should see the actual council
5:06 get spun up. So, here is the brief that
5:07 the council is going to judge, and we're
5:08 going to see each of these agents get
5:09 spun up. The contrarian, the
5:11 expansionist, and then the other ones.
5:12 And while this is running real quick,
5:15 what I want to do is take this, open up
5:17 another session, and just say this is my
5:19 idea, and just say, do you think this is
5:20 good? Do you think this will work? Do
5:22 you think I can make money? And it'll
5:23 just be cool to come back to that after
5:25 we see what the council says and see
5:27 what it would have said if we didn't do
5:28 that. So anyways, you can see we have
5:31 now these five sub aents running and I
5:32 will check in with you guys when that is
5:34 finished up. Okay, so the verdict here
5:36 is to reshape and the confidence in that
5:38 is very high. So in one line it says
5:41 kill the $9 YouTube to LinkedIn posts
5:43 product exactly as described. It's a
5:44 free no login commodity wrapped in a
5:46 subscription that's structurally built
5:48 to churn. But keep the engine and aim it
5:50 at a narrow paying niche with the two
5:51 features that are the actual moat which
5:53 is provable voice matching and direct
5:55 scheduled posting. So here you can see
5:57 it goes into the why. It goes into our
5:59 biggest risk which is no moat and a free
6:01 substitute and no distribution with no
6:03 audience and a few hundred budget. CAC,
6:04 which is customer acquisition cost, will
6:07 exceed a $9 LTV, lifetime value, on day
6:10 one, and you'd ship a polished MVP,
6:12 minimal viable product to singledigit
6:14 signups. It goes over the biggest upside
6:15 if we do want to, you know, look glass
6:18 half full, the money read, the cheapest
6:19 48 hour test. So, what it recommends we
6:21 do before we go write any code, which
6:23 would be pick one niche, DM or email 20
6:25 to 30 of them, and see if there's
6:27 actually a market there. See if people
6:28 would pay for that. So, here's the
6:30 overall score. The Contrarian gave us a
6:31 2 out of 10. Expansionist gave us an 8
6:33 out of 10. We got a three out of 10, a 2
6:35 out of 10, and a 2 out of 10. So,
6:36 obviously, we would want to reshape this
6:38 idea. Now, let's just go over real quick
6:40 to the basic claude and see what we got.
6:41 Looks like there's a few questions I
6:42 have to answer. So, let me do that real
6:43 quick. Actually, I have to run this
6:45 again because it actually used the roast
6:47 skill without me asking it, which proves
6:49 that it's, you know, that that's good,
6:50 right? But, let me just run this again
6:52 and explicitly say don't use the roast
6:53 skill. And now, this one has come back.
6:55 It did give us a good analysis and said
6:56 like, you know, this probably is
6:57 something that you want to rework a
6:59 little bit before you actually go ship
7:00 it. But this advice is so much more
7:02 generic and we didn't get the right
7:04 perspectives and it doesn't even really
7:06 tell us what we should do in order to
7:08 actually push this out the door. And
7:09 because we just got Opus 4.8 and the
7:10 models are going to get better and
7:12 better. The whole sick of fancy thing is
7:13 something that all of these model
7:15 providers are aware of and you know
7:16 taking steps to make sure that it's not
7:18 just a yes man. But clearly if you
7:20 compare these two outputs, getting sort
7:22 of a council that has different areas of
7:24 expertise and different personas is
7:26 going to be much better to actually help
7:28 you analyze business decisions and look
7:29 at what you should be doing in order to
7:32 make money. So that is how the roast
7:33 skill works. Even if you don't want to
7:34 use that exact skill, I think the
7:37 methodology of having your ideas always
7:39 be stress tested, always have a devil
7:40 advocate, look at it from different
7:42 perspectives is the best way to make a
7:44 good decision. even if it's not
7:45 explicitly about making money, it's a
7:47 really good way and a really great way
7:49 to just default when you're talking to
7:51 Claude or any AI model for that matter.
7:53 All right, so that was roast. Now, once
7:55 Claude actually builds something for
7:56 you, there's one step that it almost
7:58 always skips, and it's the one that can
8:00 cost you days to fix. So, Claude will
8:02 hand you something that looks finished,
8:03 but something being finished and
8:04 something actually working are not the
8:06 same thing at all. And this is once
8:08 again a real measured problem. There was
8:09 a study out of NYU where researchers
8:12 reviewed around 1,600 programs generated
8:14 by GitHub Copilot. Well, we all know
8:16 that Copilot isn't the best, but
8:18 anyways, roughly 40% of them had
8:19 security vulnerabilities in them. And
8:20 the scary part about these mistakes is
8:22 that they're super easy to miss. So, a
8:24 lot of the time you don't even know they
8:26 exist until something crashes in front
8:28 of a client or in some sort of like
8:29 worst case scenario for something to
8:31 crash like a live demo. I remember one
8:32 specific time where we were shooting off
8:34 a bunch of emails to people who wanted
8:35 to work with us, but we basically didn't
8:37 have capacity. So, we were shooting off
8:38 emails to let them know. And we had
8:40 hundreds of people to reach out to. And
8:41 so, the agent that I was building told
8:42 me that it had sent out all those
8:44 outreach messages. And I didn't know
8:46 until 4 days later that, you know, I
8:47 checked the email and saw that it only
8:49 sent about the first 25% of them. So,
8:50 I'm not exactly sure why because it
8:52 confidently told me, yeah, I sent off
8:54 all those emails. Everything is good to
8:55 go. So, not only did it not do what it
8:57 was supposed to, but it also lied about
8:59 it. And so in that situation, it wasn't
9:00 really a huge deal, obviously, because
9:02 that wasn't like a super high-risk
9:04 situation where it costed us a ton of
9:05 money. But imagine what it would have
9:07 looked like if it was legitimately
9:09 building a bunch of dark code, meaning
9:10 you know, code that you didn't write and
9:12 it's shipping features or building out
9:14 automations, that's a pretty legit like
9:16 big deal, which if it lies about it or
9:17 does it poorly, that really could result
9:19 in your business losing a ton of money.
9:21 The fix here is to make Cloud check its
9:23 own work before it ever hands it to you
9:24 and then also having it check the work
9:26 that it already handed to you. So, think
9:27 about like how cars get built at the
9:29 factory. They test out every single
9:31 piece of the car on its own. And then
9:32 when the whole thing comes together,
9:34 they test it a bunch again. And that's
9:35 basically the methodology that we want
9:37 to work with when we're using Claude.
9:38 This one's a little different from the
9:40 others because it's not really like a
9:41 pre-built skill that I can give you.
9:43 Like I said, it's more of a methodology.
9:44 It's more of a mindset shift. And
9:45 there's two parts to it. Like I said,
9:47 the first part is verification. Before
9:48 Claude ever hands something to you, you
9:50 want it to check the work as it goes.
9:51 And then, of course, by the time it
9:53 tells you it's done, you stress test it
9:54 more. and you try to find those edge
9:57 cases that you collectively didn't think
9:59 about both you and Claude were planning.
10:00 Now, how you actually do that like
10:03 stress testing or the verification is a
10:04 little bit different depending on what
10:05 you're actually building because if
10:07 you're trying to verify a landing page,
10:08 that's totally different than verifying
10:11 like an edited video or a data pipeline
10:12 or something like that. So, so this
10:14 isn't just like one magic button you can
10:16 press. Like I said, it's more of a habit
10:17 that you bake into Claude and more of
10:19 the way that you prompt and the way that
10:20 you think about working with Claude
10:22 code. So, let me show you guys what this
10:23 actually looks like. I'm going to have
10:25 Claude build out a landing page with a
10:27 weightless form for our app or our
10:28 product. And then it's going to verify
10:30 it with screenshots and it's going to
10:31 look at this page as if a real person
10:32 was actually looking at it. And then
10:34 we're going to have it stress test it by
10:35 clicking through the buttons, submitting
10:36 a bunch of forms, and trying to break it
10:38 and see if there's anything that we need
10:42 to fix. Okay. So now its recommendation
10:43 for us to verify if this is going to
10:46 work was to DM some people and get the
10:47 proof of concept, right? And so what we
10:49 want to do is have a landing page to
10:50 actually send them to somewhere that
10:52 shows the features and the brand and
10:54 gives it a feel and then also has a
10:55 little bit of a wait list to see if
10:57 people actually opt in. So I have this
10:58 prompt here. I'm not going to read the
11:00 entire thing and I will kind of slowly
11:01 scroll through it if you want to pause
11:03 and look at what I've written up here.
11:04 But the idea is that we have a
11:06 verification loop. So right here, right
11:07 after you build it, do not trust that it
11:09 looks right. Verify yourself with
11:11 Playright and I need to add CLI here
11:13 before reporting back. So start the
11:15 local server, use Playright CLI, which
11:16 is just basically computer use. So it
11:18 can open up the actual website, look
11:20 around, take screenshots, click around,
11:21 things like that. And it needs to verify
11:23 it. So screenshot each section
11:25 individually, look at them, and if you
11:26 need to, you'll come back and iterate,
11:28 right? So the whole point is you repeat
11:30 the loop and you iterate, and you only
11:32 stop once every section has been
11:33 screenshotted at both viewports, and
11:35 there are no visible errors and the
11:37 weightless form looks clean. And I gave
11:39 it down here a definition of done. So
11:41 what I'm going to do is copy this prompt
11:43 and just put it right in there and hit
11:45 go. Now, obviously, like I said earlier,
11:47 depending on your actual whatever you're
11:49 building right here, your verification
11:50 loop will look a little bit different.
11:52 In this case, it's able to look
11:53 visually, take screenshots, things like
11:55 that. But the whole idea is a lot of
11:56 times on the first shot, you might hear
11:58 this thing called like one shot prompt.
11:59 On the first shot, AI will maybe get
12:01 you, let's just say 65% of the way
12:03 there, and your job then is to review
12:05 and to judge and add your taste and go
12:06 back and forth. But what if you could
12:08 have AI get you 90% of the way there
12:10 first and then you iterate from there?
12:12 And the whole idea of verification and
12:14 checking its work on the way is where
12:15 you can have it be a little bit less
12:17 lazy and it doesn't actually stop until
12:19 it gives you something that you can
12:20 basically quickly review and shoot off
12:22 because it's a complete waste of time if
12:23 it gives you something and then you have
12:24 to make all these changes, right? Like
12:25 think about it. If you wanted someone
12:27 who reports to you, an actual human, you
12:29 would want them to give you a report
12:30 that you're able to just review once
12:32 over and it all looks good and it's all
12:34 real. You wouldn't as much value the
12:35 employee who's giving you things to
12:37 review and every single time he or she
12:38 hands you something, you have to make a
12:40 ton of changes. So, as you can see, it
12:42 is throwing together this little task
12:44 list, and it's going to go through and
12:46 run the verification loop and fix until
12:47 there are zero errors. So, I will just
12:49 check in with you guys when that is
12:51 done. Okay, so everything checks out end
12:53 to end. Apparently, it's done and
12:55 verified, not just asserted. We have a
12:57 live URL, which I'll click open in a
12:58 sec, but let's see. It said it built a
13:01 single page, premium weight list landing
13:02 page for Cadence with all eight
13:04 sections. The verification loop actually
13:05 ran and passed. Playright took
13:07 screenshots of all the sections. If I
13:08 open up this folder right here that you
13:10 can see it made cadence landing, we have
13:12 like the actual code that went into the
13:13 building out the site. We have the
13:15 nodes, but right here we have
13:17 screenshots and we can see desktop we
13:19 have 11 and on mobile we have also 11
13:21 that were taken. So that is really
13:22 really nice to see. And just to show you
13:23 guys, if I clicked in here, we can see
13:25 that it's actually looking at what the
13:27 page looks like based on mobile or
13:28 desktop view. And that's how it's able I
13:30 mean obviously this is pretty AI sloppy.
13:32 Like it's very generic. That's not the
13:33 point. The point I'm trying to make
13:35 right now is the verification loop,
13:36 right? Obviously, we could do things
13:37 from a design perspective to make this
13:39 feel more branded to feel less AI
13:41 created. So, anyways, let's take a look
13:43 now at the actual site. If I click open
13:45 here, we're in the VS Code inapp browser
13:47 sort of thing. We can see cadence
13:48 features. Click on this button that
13:51 zooms us down how it works. Pricing. Let
13:52 me just zoom out this a little bit.
13:53 There we go. Um, join the weight list
13:55 brings us down here to this section. We
13:57 have different LinkedIn followers,
13:58 annual revenue, stuff like that. And
14:00 these buttons down here work as well. So
14:02 from a visual perspective, besides the
14:04 fact that it is pretty AI generic, it's
14:06 good, right? Like everything is in line.
14:08 Nothing's out of bounds. All the text is
14:10 readable. The sections are clean.
14:12 There's not any like bugs or glitches. M
14:14 dash. Uh-oh. But anyways, that is
14:16 showing us how we can get outputs using
14:18 sort of a verification loop. Now, we can
14:20 even take this one step further. Part of
14:21 having it check its own work is not just
14:23 in the build process, but it's also in
14:25 stress testing process, right? So
14:27 because we have the ability with our
14:29 website to test out and making sure that
14:30 things are functional, we haven't yet
14:32 tested filling out the form. So what I
14:34 can say is awesome. So what I want you
14:36 to do now is use Playright CLI and open
14:39 up a headed browser and show me that you
14:40 are submitting forms and do multiple
14:42 passes of submitting forms with
14:44 different dropown options and you know
14:45 different types of emails, different
14:47 types of phone numbers. Basically just
14:48 to stress test this thing to make sure
14:50 that there's no bugs in the form
14:52 submission aspect of this site. And so
14:53 when I say headed browser, that just
14:55 means that I can like watch it rather
14:56 than a headless browser would be running
14:58 in the background and we wouldn't see it
15:01 even though it is actually going on and
15:02 working in the background. So here you
15:04 can see it just opened up a tab. It just
15:06 submitted a form and it's filling out a
15:08 bunch of different versions right here.
15:09 It's doing it really quick, right? We
15:11 saw different dropown options, different
15:12 types of emails, different types of
15:15 names. And obviously we don't have any
15:16 backend configured yet, but that would
15:18 be the next step, right? We could
15:19 configure a backend and then have it
15:20 test it out more. It even I don't know
15:22 if you guys saw that it was trying out
15:24 putting spaces in weird spots. It was
15:25 putting some spaces before the email.
15:27 There we go. We just got a bug there
15:28 where it wasn't a valid email right
15:30 there again. So, we're we're seeing all
15:31 these edge cases that humans might
15:32 actually get. There's another one.
15:34 Right? And so, the idea here is that
15:36 it's finding things that you might not
15:38 be able to think of or you don't want to
15:40 sit here and manually do that, right? So
15:41 that is what's really cool about this
15:43 because we get the creativity of a model
15:46 like Opus and then we get the ability
15:48 for Claude code to actually do stuff
15:49 like this and now we understand what all
15:52 the edge cases are and what users might
15:54 do. Anyways, I'm going to go ahead and
15:55 just let this keep running. But two
15:57 parts of having it check its work on the
15:58 build side to save you some time and
16:00 then of course on the stress testing
16:01 side to also save you some time. Looks
16:03 like it found all the edge cases and it
16:05 decided that that was good enough for
16:06 that first run. Right here you can see
16:09 all 22 of its 22 tests passed. So, it's
16:11 going to pull the evidence. It's going
16:12 to look at those passes and the
16:14 rejections and then basically just let
16:15 us know what we need to change, if
16:17 anything. So, there you go. We can see
16:18 we had eight valid submissions and then
16:21 we had 14 malformed submissions. But
16:22 then it said two honest non-blocking
16:24 notes. No duplicate guard. So, the same
16:26 email could join twice. And email
16:29 validation is intentionally lenient. So,
16:31 structure only, not deliverability.
16:32 Meaning people could submit a fake
16:34 email, but if it fits the structure of
16:37 like named doommain.com, it will go
16:38 through. So there's not a deliverability
16:40 check. So those are two things that if
16:41 we wanted to action, we could action
16:43 that honestly I wouldn't I didn't think
16:44 about right away, you know, in our
16:46 initial build. So very very helpful. All
16:47 right. So those were the first two
16:49 upgrades. Now those work for every
16:51 single output clause gives you. But to
16:52 make them work, you actually have to get
16:54 the output in the first place. And most
16:56 of the time, the reason people move slow
16:57 has nothing to do with what they're
16:58 doing when they work with Claude. It's
16:59 that they literally hit a wall. The
17:01 conversation starts to fill up. Cloud
17:03 gets slower. It gets worse. It starts
17:04 to, you know, burn through your usage
17:06 limit. and it feels like it just has no
17:08 memory. And once again, there's a study
17:10 on this. It's basically called context
17:12 rot. Researchers tested 18 of the top AI
17:14 models out there, including Claude. And
17:15 every single one of them starts to
17:17 perform worse as the conversation gets
17:18 longer. Even if it's really, really
17:20 simple tasks, that's where you start to
17:22 get just so much degrading in the
17:23 performance and, you know,
17:25 hallucinations. And the problem is that
17:28 drop off starts way before anywhere near
17:29 the context window being completely
17:31 full. So more is not better. And a
17:33 longer conversation literally makes
17:34 Claude get dumb. So, think about
17:36 Claude's context like a desk. If you
17:37 piled up a bunch of paper onto it and
17:39 then you needed to find one specific
17:40 document, it's going to be way harder to
17:42 find. It's going to take you way longer
17:43 because there's so much information in
17:44 there. And on top of that, if you're not
17:46 running the best version of Claude,
17:47 meaning like the best, most capable
17:49 model, whether that's Opus 4.8 or
17:50 whatever it might be, it's going to
17:52 design things worse. It's going to build
17:53 sloppier code. And it might even get
17:55 worse at the reviewing and the
17:56 verification and the stress testing. So
17:58 those two things that secretly decide
18:00 whether you make money with Claude are
18:02 managing your context and making sure
18:03 you're working with the right model for
18:05 the right use case. So the fix here is
18:06 handling your context properly. There's
18:08 a lot of things that go into that, but
18:09 basically just making sure that you're
18:11 taking care of that and it's on top of
18:12 your mind before it quietly wrecks your
18:14 outputs. And there's a couple commands
18:16 worth knowing here. So first one is
18:17 using /context, which lets you see
18:19 exactly what's eating up your context
18:21 window. /clear lets you wipe the whole
18:22 thing and start fresh. Instead of using
18:24 /compact, which like compacts your
18:25 conversation and then you can, you know,
18:27 keep going, I built my own custom skill
18:29 called / session handoff. So before I
18:30 ever clear anything, I run session
18:32 handoff. It writes me a summary of
18:33 everything that matters, what we're
18:34 working on, the key files we've produced
18:36 or key files that hold information, any
18:38 open decisions that I've made, and then
18:40 basically exactly where to pick back up.
18:41 So, all I have to do is run the session
18:43 handoff, copy that message, clear the
18:45 context, paste it back in, and now I'm
18:46 sitting in a completely clean window,
18:47 but I'm basically just picking up
18:50 exactly where I was, and it doesn't feel
18:52 like I lost anything. Now, let me show
18:53 you what types of things you want to
18:54 think about when it comes to making sure
18:56 you're not hitting that context rot
18:57 territory. So, the first thing, and the
19:00 reason why I'm using this uh CLI version
19:01 right now, what I typically use anyways,
19:03 you can see my status line down here.
19:05 What I'm looking at is throughout my
19:07 sessions, I can see the model I'm using,
19:08 what the context window is. I can see
19:10 the effort that's being used. I can see
19:12 basically a visual indicator of how much
19:15 of my context window has been filled up.
19:18 So 12% which is about 125,000 tokens out
19:20 of our a million token window. I don't
19:22 really like to let this really pass like
19:23 a quarter million. Whenever this passes
19:25 a quarter million, I typically tend to
19:27 start a new session. So a couple things
19:28 that you want to leverage, right? We
19:30 talked about SLcontext. So if I do this,
19:31 this is going to actually show me and
19:33 visualize what is going on in our
19:35 session. So we can see, wow, all of
19:37 these MCP servers might be well, these
19:38 aren't actually taking tokens. These are
19:40 load on demand, but if they were loaded
19:41 in, that would be a lot of tokens. We
19:42 can see we have free space, we have
19:45 skills, memory files, system tools,
19:46 system prompts, all of that kind of
19:49 stuff. And this also will show us, you
19:50 know, how many tokens roughly for each
19:52 of those items. And this is good to be
19:53 able to clean up your products a little
19:54 bit if you want to make sure you're not,
19:55 you know, starting off with just a ton
19:57 of context already eaten up. It also
19:59 right here gives a suggestion. So read
20:02 results using 490,000 tokens, 49%. So
20:04 you could save about 140,000 tokens
20:06 here. But anyways, that is one thing.
20:09 You could also do a /compact or cloud
20:10 code has its autoco compacts. But
20:12 honestly, I don't leverage this very
20:13 much. It takes a long time. I I
20:14 basically built my own skill, which is
20:16 called session handoff, which I will
20:17 give you guys for free of course in the
20:19 free school community. But when I run my
20:20 session handoff skill, I've basically
20:22 prompted this thing to give me a summary
20:24 of what we've done. Um, you know what?
20:25 I'll just wait till this runs and I'll
20:27 show you exactly what it gives us. All
20:28 right. So, this is the session handoff.
20:30 We get where it started, decisions that
20:32 are locked, and what shipped, key files,
20:34 running state, verification, deferred
20:35 and open questions, and then pick up
20:37 here. So, now I can just do a /copy,
20:39 which grabs everything that Claw just
20:41 outputed to us. I do my SL clear. You
20:42 can see the context window completely
20:45 resets. I paste that in, and now our
20:46 project has the exact context that we
20:48 were basically working in. It has all
20:49 the files. It knows where to look. It
20:50 knows what we were doing, and it knows
20:51 where to pick up. And it's just super
20:53 super helpful to be able to just
20:54 constantly do a session handoff and
20:56 clear. or even if I wanted to do a
20:57 session handoff and then move it over to
20:59 like I don't know a different model or
21:00 maybe even codeex or something like
21:02 that, I'm able to do so super super
21:04 easily. And sometimes it'll even do
21:05 something like this where it says I've
21:06 got the handoff. Let me quickly confirm
21:08 the current running state before I
21:10 recommend our next move and we keep
21:12 working. So that skill is super super
21:15 helpful and easy to use. Okay, so this
21:16 is now the last upgrade and once you
21:18 start using it, you'll produce more
21:19 progress in a single day than most
21:21 people can produce in a week. So, no
21:23 matter how good your prompts are,
21:24 there's still one hard limit, and that's
21:26 the fact that you can only point Claude
21:27 basically one direction at a time
21:29 because you are the bottleneck. You are
21:31 the decision maker and the reviewer. And
21:32 Enthropic's own engineering team
21:34 actually tested this directly. They set
21:36 up a lead agent coordinating a team of
21:37 little sub agents all working in
21:38 parallel. And they compared it to a
21:40 single agent doing the whole job alone.
21:42 The team setup obviously outperformed
21:44 the single agent by over 90% on their
21:45 internal research evaluation. So real
21:47 quick, in case you don't know what a sub
21:48 agent is, a sub agent is basically a
21:50 separate claude that gets its own task
21:52 and its own clean context window. It
21:54 works all alone by itself and then it
21:56 reports back to that main terminal
21:57 session. So instead of one worker doing
21:59 everything, you know, one step at a
22:00 time, you have a whole team of them
22:02 running and they're each working on one
22:04 of the pieces at once. So personally, if
22:05 I'm doing something like planning out a
22:07 YouTube video, I'll maybe have one doing
22:08 research on a certain topic and one
22:10 doing research on another and one maybe
22:11 looking through comments on past videos.
22:13 The key here is anything that can happen
22:15 in parallel independent of each other, I
22:17 will spin up sub aents to do that. And
22:18 then when everything gets synthesized
22:19 together, I can take that output and
22:21 just do whatever I need to do with it.
22:22 And then I'm going to add one more thing
22:23 on top of that which makes it feel
22:25 completely like the future. And that is
22:27 a command called /goal. So using goal
22:29 that lets you set a finish line, an
22:31 actual completion condition, and then
22:32 Claude will basically just work turn
22:34 after turn for as long as it takes until
22:35 you hit that condition. And the cool
22:36 part about that is that there's a
22:38 separate evaluator. there's a second
22:40 model that checks every single turn to
22:42 see if, you know, done equals true or
22:44 not. So, Claude doesn't get to declare
22:45 itself done. A different model has to
22:47 look at it with a different persona and
22:49 actually grade it and see if it's done.
22:50 And that's what's so cool about it
22:52 because the whole problem in upgrade one
22:53 was that Claude would just agree with
22:55 itself or agree with you too often. So,
22:56 now you have a different one and it
22:58 literally separates the worker from the
23:00 judge. So, let me go ahead and give it
23:01 one job, set the goal, and run this
23:03 live. And this last move is cool because
23:05 it basically stacks every single upgrade
23:07 from the whole video into this one test
23:08 because the idea got validated with the
23:10 roast. It verified its own work before
23:12 declaring done. And that's the
23:13 verification methodology from upgrade 2.
23:15 It spins up a whole team of sub aents.
23:16 Each one runs in its own clean context
23:19 so nobody hits the context rot wall. And
23:20 then we use goal to drive the entire
23:22 thing home. Okay, so this one is really
23:24 really cool because it combines
23:25 basically everything that we've talked
23:27 about so far. We talked about making
23:29 sure that we have the right idea by
23:30 having some sort of counsel and playing
23:32 devil's advocate. We then talked about
23:33 how you can have claude verify and check
23:35 its own work. Then we talked about
23:36 context and making sure that things are
23:38 clean. As you can see, we just set our
23:40 session handoff. And now we can loop all
23:42 of that back together by using things
23:44 like sub aents and/goal to help us work
23:46 faster. So if I do / goal right here,
23:48 you can see it says set a goal. Keep
23:49 working until the condition is met. And
23:50 then I'm going to basically just paste
23:52 in my prompt. So I'm going to shoot this
23:54 off and we'll see what it says. And
23:55 you'll notice that there's elements that
23:56 we've talked about like I just
23:58 mentioned. So we have our product. So
23:59 the goal is to build a complete ready to
24:01 execute go to market kit for our product
24:03 and save it in this project. The product
24:05 is obviously our web app. We have our
24:07 ICP here. And what's really cool is
24:08 inside of the goal, we're able to
24:11 leverage sub aents. So use parallel sub
24:12 aents, one per deliverable. So there
24:13 should be six and they each have their
24:15 own context. And they're each going to
24:16 produce different files that don't
24:18 overwrite each other. So this is what
24:19 we're having it create. And yet down
24:21 here you can see that I defined when
24:22 this thing is done, which is that all
24:24 six files exist and none of them are
24:26 empty. The market research has six plus
24:28 competitors. The personalized drafts has
24:30 25 number drafts. Things like this. The
24:31 more objective you can be with your
24:32 goal, the better that it's actually
24:34 going to work because obviously it's
24:35 going to keep working until it thinks
24:36 that it's done. You also will notice
24:38 that in here I said after the sub agents
24:40 finished, run a verification pass
24:42 yourself. So open each file, confirm
24:44 that it meets the bar, fix anything thin
24:46 or generic before you declare yourself
24:47 done. And so this is just going to run.
24:49 And now because I frontloaded all of my
24:51 thinking into that prompt and set the
24:52 goal, I can just kind of walk away and
24:54 do whatever I want until this is done.
24:55 So this will be running in the bottom
24:57 right. It'll say goal active. It'll tell
24:58 us how long the goal has been running
25:00 and then when it's done it'll say goal
25:01 done. So I'll check in with you guys
25:03 when we actually have that finished goal
25:04 back. All right, so that just finished
25:06 up as you can see and it only took about
25:07 8 minutes. So one thing about the goal
25:09 is just because it's a goal and just
25:11 because it has a loop ability doesn't
25:12 mean you have to set goals that are
25:14 going to run for hours and hours. I use
25:16 goal a lot and most of the time I use
25:17 goal. It's runs that take less than, you
25:19 know, 20 to 30 minutes because I'm able
25:21 to just be super clear about my prompt
25:22 and just have more confidence that it's
25:24 going to achieve the goal. So 8 minutes
25:26 we have our six different files and keep
25:27 in mind this spun up six different sub
25:29 aents and all of the sub aents were
25:31 working on their files independent in
25:32 parallel. So that's another reason why
25:34 this was able to go pretty fast. But all
25:35 of these have been verified. All of
25:37 these have been checked and now it would
25:39 be on us to be able to look at the
25:40 positioning, the market research, the
25:41 launch plan, the outreach templates, the
25:43 outreach drafts and the content
25:44 calendar. And because we've looped
25:46 together all of these upgrades and all
25:47 of these skills, we're in a really good
25:49 spot now to be able to start executing
25:51 on this vision. And think about this, in
25:53 total, all of these demos probably took
25:54 me under an hour. And so if you really
25:56 wanted to go, you know, start like spin
25:57 up a business like this, you're going to
25:59 put more than just an hour in. But think
26:01 about if you put in like a week of
26:02 focused work with all of these
26:04 strategies, ideation, building things
26:05 out, and then having this full launch
26:07 plan and all of this stuff ready to go.
26:08 Where could that take you? And how could
26:10 you have just leveraged cloud code to be
26:11 able to have done something that
26:13 probably would have taken a team of 10
26:14 and probably would have taken more time.
26:16 So just to show you what's in here, if I
26:17 click on the go to market, we can see,
26:18 let's just first look at the
26:21 positioning. We have our ICP. We have
26:23 our segment A, our segment B, our core
26:25 offer, our tier ladder. Looks like
26:28 pricing got locked at 1939 and 999 per
26:30 month. We have upgrade logic. We have
26:32 our oneline value prop. And we have our
26:34 three sharpest objections with
26:35 rebuttals. So I could use chatbt for
26:37 that. We have I don't post on LinkedIn
26:39 enough to need this. AI posts sound fake
26:41 and will hurt my brand. So we have good
26:42 rebuttals for all of those. And we could
26:43 obviously come through, read all of
26:45 this, and put our own personal touch on
26:46 it. We've also got our market research.
26:48 So, we've got our product, our wedge,
26:50 our ICP, competitors, which found looks
26:52 like seven of them, and we said it
26:53 needed at least seven, I believe. We
26:55 have some adjacent ones as well. We've
26:56 got a full comparison table of these.
26:59 We've got where cadence fits, why $19 is
27:01 the right entry price. So, as you can
27:02 see, all of our sources are here. This
27:04 is very in-depth. We've also got our
27:06 launch plan. So, this is a 14-day launch
27:07 plan, which we would basically just be
27:09 able to follow. We've got our outreach,
27:11 and then we would start making our
27:12 content based on this calendar. So
27:14 anyways, that is how we're able to
27:16 leverage sub agents, goals, automations,
27:18 other things like that to make sure that
27:19 you stop being the bottleneck. You are
27:21 very much changing from the builder and
27:23 producer to the problem solver, the
27:25 decision maker, the reviewer, the judge.
27:26 That's how you need to leverage this
27:28 type of technology to help you grow your
27:29 business, to help you make more money.
27:32 So that was the four upgrades. Stop
27:33 letting it agree with you so you build
27:34 the right thing. Make it check its own
27:36 work so you ship stuff that actually
27:38 works. Manage your context so Claude
27:39 stays sharp. And stop being the
27:42 bottleneck. Use sub agents. use /goal so
27:44 that stuff can run without you. So now
27:45 you can use these upgrades to make more
27:46 money using Claude. You can get
27:47 everything that I talked about today
27:49 inside of my free school community.
27:50 There you'll also find hundreds of free
27:52 resources and courses and over 400,000
27:54 people building with Claude. And if
27:55 you're ready to go deeper and build an
27:57 AI business, then you can join my plus
27:58 community where we hop on weekly calls
28:00 to answer your questions. The link for
28:02 both of those communities is in the
28:03 description. But anyways, that is going
28:04 to do it for this one. So if you guys
28:05 enjoyed the video or you learned
28:06 something new, please give it a like. It
28:08 helps me out a ton. And as always, I
28:09 appreciate you guys made it to the end
28:10 of the video and I'll see you all in the
