The Easiest Way to Automate Your Life With Claude

0:00 Today, I'm not going to show you some complex AI agent setup that never actually works. Instead, I'm going to show you the easiest way to automate your life with Claude. And to do that,

0:09 we're going to walk through a simple six-step automation framework that I've taught thousands of other people. And each of these steps builds on the last. And yes, we'll build an automation

0:17 together, start to finish. But more importantly, whether you're 25 or 65, technical or not, you'll leave with a repeatable process you can use for anything in your personal or

0:28 professional life. Now, before I get to step one, we need to establish the tools we'll be using to build out these automations. You have to identify your minimum viable stack. Today, we're not

0:36 going to run through some complex Hermes agent or OpenClaw Mac Mini setup. I personally don't need it, so I highly doubt you need it. Instead, we want to set up something simple enough that it

0:46 solves our problems. And so, every automation is really comprised of three things. The trigger, what causes it to run, the logic, what it actually does, and the monitoring, where you see what

0:56 happens and if you need to fix it. And the problem with complex setups is they may have slightly more powerful logic potentially. Maybe I'm still on the fence, but the monitoring, the

1:04 maintenance, and setting up the trigger is way too complicated for 99% of people. For me, I ran an engineering team at JP Morgan. I was a COO of a tech startup with over $30 million. And now

1:13 I'm one of the top YouTube AI creators. And for me, none of this is needed. Instead, what we're going to walk through today is all I use. Now, with that, if you're not using the exact

1:22 setup that I walked through today, all six of these steps that I cover are universal principles that you can apply to whatever setup you're using. So, what will we be using today? For the trigger,

1:32 we're going to use Claude routines. For the logic, we're going to be using Claude skills. And for monitoring, we're going to use the Claw desktop app. The setup is going to be simple, but the

1:40 logic behind how you're using it. That's where the sauce comes from. So, getting into step one, it's the automation spike. This step is all about getting a quick win. And in engineering, we have a

1:49 concept called a spike. Before you build anything that's perfectly polished, you build the fastest, ugliest version that connects all of the pieces end to end. The goal here is to just prove that

1:58 there are no technical blockers between you and what you want. We want to be able to answer the question, is this actually possible? And the reason that we do this first is it creates a

2:07 foundation we can build off of and it gives us a initial dopamine hit of momentum so we don't get discouraged. But more importantly, number two is it saves us time in the long run because we

2:17 won't be spending time polishing the first part of an automation just to realize it's impossible to do the next part of the automation later in the process. So to do this, ask yourself

2:27 what are all the necessary pieces of the puzzle that are required to make this happen. On screen is a prompt that you can run which will help you take an automation idea that you have and

2:36 identify what is needed to fully build out the automation spike. For our daily morning brief, I want to see a couple of things. The first is I want to see my email history and my Slack history. The

2:45 next is analyze that and share a summary with me of anything I missed. The third an inspirational quote because why not? The fourth step is send an email to me through Claude. And the fifth is I want

2:55 this to run daily. Okay, so that's the general structure of what we're building. And you may be like, isn't that a waste of time? This is super simple. Well, in this case, I'm

3:03 intentionally choosing something simple to show you why this is so important. What I do is I take these requirements to Claude and I say based on these automation requirements, how can I build

3:13 this using the Claude desktop app end to end, keep it concise and confirm how to do it and if it's possible. It then gives me a guide on how to do it and then it tells me that I can do it end to

3:22 end. But let's say I was filming this before August 18th. This wouldn't have actually been possible. Anthropic just made it so I can send emails through Claude, which would have been a blocker

3:33 from me doing an email automation here. A thing that feels obviously possible, for example, Claude sending an email for you, may not always be the case. And that's why this spike process is so

3:44 important. But Claude saying it's possible is just the first part. You actually have to go and build it. Don't just take Claude's word for it. So I click the plus add connectors. I connect

3:54 everything. And then I go and use this prompt to go ahead and run the daily brief automation. Here you can see it running. It gets information and then sends me an email with an overview with

4:02 an inspirational quote which probably has some room for improvement. In my eyes though, I now see that it's actually possible. I can answer this question. Is it possible? Yes. That's

4:11 step one. I did it quick. I got the dopamine hit and I'm ready for step two. And if you're wondering on some things that you should consider doing a spike on before building the automation based

4:20 on your security permissions, maybe your work setup, here is a list of things that are worth trying. At this point, it's time for step two, which is make the results transferable. So, you have

4:28 the automation set up at a high level. Now, it's time to try and actually automate this. Now, what are our options to actually do this? We're going to use Claude routines, which is pretty simple.

4:37 It lets you essentially run a prompt at the time you want. So, if you want to run a prompt at Monday at 8 a.m., it's super easy. So, how do we actually take what we just did, the spike, and then

4:47 bring it through to Clawed Routines? There are three options, and for the first two, I'll explain why they're flawed. You can copy and paste the prompt you use to create the automation

4:56 in the first place and then run that in clawed routines. This is not ideal because it's rediscovering how to do it each time, which will lead it to being slower, costing more tokens, and just

5:06 being more inconsistent. Another option is we could ask Claude to create a reusable prompt that you can bring into Claude routines for this automation. This is better, but how do you easily

5:16 update and test this on your machine? Are you really going to copy and paste prompts back and forth through routines? probably not. That's a lot of work to maintain, which is something we'll cover

5:25 later in this video. Now, the third option is we can create a skill that is directly referenced in the routine. This way, if we update that skill, the routine automatically updates, too. This

5:35 is the winner. This is a concept I call skill- driven automations, and it is non-negotiable. So, to actually do this, we go back to chat that we created the automation in, and then we use this

5:44 prompt to create a skill based on this conversation. Once that's created, we can go into the routine and then just reference that skill /aily brief. And if we decide to improve this brief in the

5:53 future, let's say we want the email overview to be more concise, I can just go to a chat window, run the brief, get the output, and say, make the overview more concise. Just go back and forth

6:03 until it's a format that I like. And then I can say, update the skill to reflect this change. Then after that, I don't have to touch the routine. It updated automatically because it

6:12 references this same skill file. When we're building out automations and we want to automate our life and scaling the system, the effort to maintain the system is the most important variable.

6:22 If you've ever automated something before, I know that you've felt the pain where something breaks, it gets outdated, and you just never get around to updating it. By using skill- driven

6:30 automations and making the automation extremely transferable, it reduces the operational burden of maintaining these automations. Next question you may have is when and how often should you run it?

6:41 which may seem obvious, but the reality is this is a trap that I see most people fall into. Now, before we get to that, we're talking about building out automations using clawed and clawed

6:48 code. But what if you want to automate writing code or building products that other people use? Which brings us to today's video sponsor, Code Rabbit, which I am absolutely hyped about. So,

6:56 AI has made writing code insanely fast. But if you streamline how code gets written and don't streamline how it gets reviewed, you are going to run into a ton of issues. And that's something I

7:05 unfortunately had to learn firsthand while launching a product with over 100,000 users. And that's why this category of tooling is so important. Code Rabbit is like having a senior

7:13 engineer in the room reviewing every change before users see it. Now, here's how it works and how I use it. When you open a PR, Code Rabbit will review your code changes and leave feedback with

7:21 fixes, something that a senior engineer would typically do. On screen, you can see it reviewing a recent PR I made for build partner.ai, which is my Claude plugin that has over 4,000 users. And

7:29 the beauty of this, it doesn't just identify the issues. It gives me the exact prompts that I can use to actually solve the issues. And if I don't really want to do it myself, I can just hit

7:38 this box and it will automatically apply the fixes for me. Now, those are great, but I do like diving a step further. So, I can use Code Rabbit to dive into all the changes I made where I can use their

7:48 change stack product. On screen, you can see how it has a PR overview page, which will help me get oriented before I look at any line of code. And this is super helpful for my products, which I build

7:57 very quickly, and sometimes I honestly just forget what is in each PR. And this helps me orient myself. And you can actually see on screen it's identified a critical bug that I have to address

8:06 after this video. From there I can see the stack overview on the left which is a history of the PR. And on the right I can speak directly with Code Rabbit's agentic chat. This is where I'll ask

8:15 questions about what I did, why I did it, and if there's any better way to do it. And so whether you need to level up what you're building solo or you want to streamline your team collaboration, Code

8:24 Rabbit is the type of tool every top performing team needs. So to get access for free, click the first link in the description and start a 14-day free trial. And my favorite part is that no

8:33 credit card is needed to do this free trial and it's just a two-click setup. So go check out Code Rabbit and click the link below. So we've gone through step one, which is the automation spike

8:41 two, which is make it transferable. Now we have to determine how and when to run it. So by definition, an automation has to run automatically. So when should you run it? How often should you run it? And

8:53 where should you actually run it? The answer to some of this in your head might be like, oh, that's obvious. I know exactly when I should run it. The daily brief, I should run it in the

9:00 morning. It's not that obvious and there are trade-offs to different decisions and as the builder of your system, you have to understand what these trade-offs are. So, the first question is when

9:10 should you run it? A general rule of thumb, run it when you're most likely to get value from it. The key word here is value. So, the daily brief automation we're building seems obvious, right? Run

9:20 it in the morning. Well, not if your mornings are crazy busy because that overview email will just get lost and you won't actually get value from it. So, maybe it should be in the middle of

9:29 the day or night. And I'm not sure, but the answer is when will you get the value from it? For me, I often like preparing for the next day the night before. So the night is actually better

9:38 for me. And what happens is most people build automations, but they don't get any value from it because they're thinking in terms of outputs, not in terms of impact. A daily brief

9:47 automation can have an identical output, but depending on when it's sent has a dramatically different impact. Okay, so that's when you should run it. What about how often you should run it? The

9:57 answer here is simple. the lowest frequency possible. Less is more. The reason for this, to build multiple automations that scale, you can't have a million alerts all the time. Be precise

10:07 with when things need to run, and this will save you time and more importantly, tokens and usage limits. And then the last question, where should you actually run it? This has to do with the system

10:16 you're using and the options it provides. For this video, we're using Claw Code and the desktop app, but the decision-making principles extend to whatever you're working on. For our claw

10:24 routines, we have two options: local or cloud-based. The rule of thumb, stay local unless you can. The second you introduce the cloud, you're working on a computer that isn't yours. In the

10:33 engineering world, there's a classic saying whenever something breaks for customers. It worked in my local environment or my local computer. I don't know why it broke in production,

10:42 i.e. the cloud. The reason this happens is the second you introduce an external machine, you're introducing additional complexity and variables that you haven't tested before. So keep it local

10:53 unless there is a reason. And on screen, you'll see a number of reasons to bring something to a more cloud-based approach. But the biggest one that actually matters is if you can't have it

11:02 miss a run. Whenever you have something running locally, it's using your local machine, which means it has to be active. And your machine won't always be active. So there's a chance that you

11:11 actually miss a run. So if you can't miss it, right, there's a high cost of error to whatever you're running. Take the time to test it and use it on the cloud. So when should you run it? When

11:19 it has the highest impact for you. How often? The lowest frequency possible. stay local until it needs to go to the cloud. We're now three steps in. We did our automation spike. We made it

11:28 transferable and we figured out exactly when and how to run it. Each of these layers has been focused on making it as easy as possible for you to set it up. But the reality is this daily brief

11:37 automation is dead simple. And you're likely going to want to do more than that. So now we need to build out the system. So layer four is enhancing your automations. So there are four things

11:46 you can do. The daily brief we created is intentionally simple. That's how everything should start. But what's the best way to take what you already have and then build from there. So there are

11:55 four things that you can do and we'll go through each of them. The first is calibrate. The next is create net new features. Then adjust output format. And then finally enhance the system design.

12:05 Calibrate is the simplest, but it's likely the step that needs the most work. This is the process of fine-tuning something so it's exactly what you want. The best way to do this is run through

12:14 the skill that drives the automation locally and go back and forth with Claude until it's a better output. After going back and forth, here's a prompt you can run that will enhance a skill

12:24 with that in mind and add any gotchas to it. This gotcha section is best practice and it is a key part of the step. The more you calibrate, the better the output will be and the greater impact

12:33 it'll have on you. The next thing you can do is create net new features. The simplest way to do this is just turn on voice mode and describe what you want to add to this automation. For this daily

12:43 brief, I can say, I want this skill to also review my calendar. Tell me how we can do that and what I need to do, if anything. This is where you may need to establish new connections. And one pro

12:52 tip here, there may be external tools that help you do things so you don't have to figure it out by yourself. And these are called plugins or MCP connections. So, for example, if I

13:01 wanted to have a career coach analyze my day and tell me what the most important thing was, I would download build partner.ai plugin and then reference the /expert advice skill that's already set

13:11 up in that plugin. And then now I don't have to worry about bringing in training data from top experts. call it Boris Churnney, Carpathy, Mark Cuban, whoever. Instead, I could use the plugin to bring

13:21 their insight into my automation. This is a great way to create new features without having to build everything from scratch. Next, you can adjust the output format. This is something I love playing

13:30 around with, and I feel that most people don't actually do this. So, two formats I love are HTML outputs and artifact outputs. So, what you can say is adjust this skill so the output is an HTML

13:41 file. Then it will create it in a different visual format or you could say create an artifact with this daily brief and then that will create a sharable URL you can access wherever and easily share

13:51 with teammates. These different output formats can really change the impact of an automation. On screen you can say the three different output formats that I use and when I use them. Number four is

14:00 enhance the system design. The more complex your automations the more important the step becomes. You want to enhance the system so they're either self-correcting or self-breaking. A

14:09 self-correcting system is something that will automatically fix itself or correct the output. And this is why the concept of loop engineering went viral because it basically tells AI to keep going

14:18 until the task is complete. In order for the loop to work, you need to have an effective way to validate the output if it should keep looping or not. So, here's a prompt that can help you with

14:26 that. And I do have a full video on my channel diving deep into this concept. Now, once you set that up, it will introduce new problems. for example, a loop that goes over and over and wipes

14:37 all of your tokens without you realizing it. And so that's why you need to make self-breaking systems. For any loop automation you create, make sure there is a maximum amount of loops explicitly

14:47 stated so there's a way for it to break. If you don't explicitly say this, there's a chance it continuously runs and then an automation will drain you out of tokens without actually doing

14:56 anything. So use this prompt which will analyze your system and identify any loops that need to add this component to it. Now that will identify if a loop just keeps looping and then break out of

15:06 it. But what I prefer doing is trying to identify these problems early and break things before wasting any tokens. So for the daily brief automation, I want to enhance it so that before it does

15:16 anything, it checks that all the necessary connections are available and if any aren't working, it sends an error message that stops the run and tells me exactly how to fix it. This is a

15:27 self-breaking system because I wanted to break fast and early instead of wasting time and money doing something that would never actually work. Clearly a little too passionate about

15:36 self-breaking systems, but I think it's really important. So on the left of the screen is before I make this change where I disconnect Slack. It then goes ahead and tries running without that

15:45 connection even though it'll never actually work. Then on the right after making it a self-breaking system, it breaks essentially right away. Establishing this clear and well

15:53 doumented breaking conditions makes it so that these automations don't suck your tokens dry without actually doing anything. Here's a prompt you can use to check all of your automation skills and

16:03 establish clear breaking rules for all of them. So remember when you're enhancing these automations, you have to calibrate it. You have to add net new features. Consider adding plugins to

16:11 streamline this. Adjust the output format. I prefer text, HTML, and artifacts. And then enhance your design to create self-correcting and self-breaking systems. Now, in order for

16:20 you to automate your life, you need to have a lot of these automations set up. So, how do you actually do this at scale? Now, before we dive into step five, where I'll cover that, in every

16:29 video I make, I give away a Claude Max subscription as a thank you for everyone who supports this channel. So, this video's winner, and I'm excited for this one, let's get Devi is the winner.

16:38 They're building a dinner assistance app. Shout out Devbie. Comments on a ton of videos. You are a legend. Excited to get you your Claude Max subscription. Now, to enter this video's giveaway,

16:47 make sure you're subscribed and let me know in the comments what automation you're building. So, now getting into layer five, which is set up your system to scale. Now, in order for you to

16:55 realistically scale out automations without maintaining these things full-time, we need to focus on reducing maintenance. Steps one to four, you can rinse and repeat to create as many

17:04 automations as you want. You know how to do it and you can set it up yourself. But once you set up these automation, it becomes a full-time job managing them. So, now what? You need to do three

17:13 things. You have to first avoid playing whack-a-ole. Then you have to consolidate your notifications. And then you need to make AI talk to explicitly, not implicitly. So what is whack-a-ole?

17:22 Well, for the younger audience who may not be familiar with the game, it is where a toy mole pops out of a arcade game and you have to try and whack it with a hammer. As you scale your

17:32 automations, you'll likely play a game of whack-a-ole, solving the same problems over and over again. For example, let's say you have three automations that send slack messages.

17:41 one of their Slack messages breaks, so you fix it, and then the issue comes up in the other two. You're playing a game of whack-a-ole, fixing the same problems, and it becomes extremely

17:49 overwhelming, and this becomes more prevalent as you build out systems at scale. So, how do you solve this? You want to think about your system as a whole and create reusable utility

17:57 skills. And this is no different than people coming from an engineering background where you write functions that are reusable. So, for the daily brief, I would actually want to split

18:05 this up. And instead of having it all self-contained in a single skill, I may change this daily brief skill so that within it, it actually calls another skill, Slack message. That way, if I

18:15 create another skill, call it monthly overview, I could also use that same Slack message skill. Now, both the monthly and daily overview skills, they reference the same messaging logic. This

18:25 way, if I change the messaging logic in one, it populates to both, and it's a lot easier to maintain that way. So to do this, here is a prompt that will look at your entire clouded system and help

18:34 you identify opportunities to create utility skills. After that, it's about consolidating your notifications. Simply put, you want to send updates from automations to a single place that you

18:45 already look at and you know that you're going to check. For me, that's Slack. For you, that might be email, Telegram, WhatsApp, whatever. Pick a location and stick with it. The third is get explicit

18:54 updates from your automations. I tell this to my human team, and it's the same with AI. Be explicit with the updates you provide. It's not I'm editing a video. It's I'm editing the automate

19:04 your life video. This will make it 10 times more clear what you are doing and what you did. The same goes for AI. Enhance these automations so that no matter what, as part of the output,

19:12 there's insight into what it actually did. So, in the daily brief, it's not I successfully ran the daily brief. That really doesn't provide any insight into what you did. Instead, you should have

19:21 it say brief analysis details. I analyzed 41 of 41 emails from austin@gmail.com. analyze 200 Slack messages and 10 calendar events. Once I make this change

19:32 now, as the person monitoring the automation, I can quickly be like, "All right, that sounds good. That looks right." And let's say it says I analyzed one of one emails and I know I got a lot

19:42 more emails than that. I instantly know that this automation may have something broken and I then can go and check. This whole concept I recently wrote about in my newsletter, but I call it green light

19:52 drift. This is the process of AI saying it did something successfully, but it didn't actually do that. So, make sure to update all of your automations to have a clearly defined outcome by using

20:02 this prompt. This way, when they run, you know exactly what happened after it ran. Now, this last step has to do about how you choose what to automate, which is probably the most important step now

20:12 that you have all the skills to build out these automations. But, let's recap how we got here. Step one is create an automation spike. Step two is make results transferable with skill- driven

20:21 automation. Step three is be strategic with how and when you run automations. Step four is run through the four ways to enhance your automations. And step five is set up your system to scale. Now

20:32 step six is automating your life. You have the skills, but what should you actually automate? Ask yourself, is this a constraintdriven automation or an enhancement automation? A constraint

20:43 driven automation is for things that fix a constraint in your day-to-day. These are things like bottlenecks. Now, an enhancement automation is one that improves your ability to provide value

20:52 or enhances the value you provide. If you can't bucket it in either of those or both, don't build it. It's that simple. Because in the world of automation, people try and do everything

21:00 and simultaneously they do nothing. And remember, the world is dynamic. So, an automation that used to be helpful may no longer be helpful. So, as you build out these automations, the pruning is so

21:11 important. You want to make sure that whatever you're doing has high valuable signal, not a lot of noise. So, for me, what are some of my favorite simple automations that are truly game

21:20 changers? The first is that I used to spend way too much time on Twitter. The reason being is it helped me stay up to date with a lot of these AI things, but I've discussed at length on this channel

21:28 that I don't actually think that's needed. So, I instead I just deleted Twitter entirely and I set up a weekly automation that sends me an HTML file on Fridays with the most important tweets

21:38 and the stories about it. This removes a time constraint which was wasting time on Twitter and also enhances my experience because it uses AI to analyze and identify what will actually help me.

21:48 Another automation is I have a weekly sync all data routine. It goes through all of my data resources, my YouTube, my email, my granola, my Slack, analyzes it, brings in the information that's

21:58 important, and then ingests it into my clawed project. It's nothing crazy, but it's super effective and it makes sure that my team is operating on the most up-to-date information. At this point,

22:07 you understand these six layers and you're fully equipped to build simple and practical workflows to automate your entire life. This has all of the processes you need to build highquality

22:18 and functional automations. But the problem you may face is that you may start automating so many things that you run out of tokens too quickly. So to solve that, check out this video where I

22:26 walk you through step by step how to optimize your system so you never hit a token limit again. I'll see you over there. pace.