# Ch 11: Capabilities: building skills (embedded Claude Skills video)
Creator: Nate Herk (@nateherk)
Transcript of Nate Herk's 2h33m 'Build your own AI operating system' course, split into its chapters. All content and credit: Nate Herk (@nateherk), https://x.com/nateherk/status/2101656269056610682. Transcribed locally with faster-whisper; names may be misheard.

[1:06:00] Okay, so we've got the foundation of our AOS setup. We've pretty much linked in our context. We've pretty much linked in connections. At least we understand, now that we've looked at all these things, we understand how we could go look at the documentation. We understand how we could grab our API keys and stuff, and we understand how to hook everything up. And now we are at this place where we wanna keep leveling up and keep moving up the chain of the four Cs. So next thing to think about is capabilities. Now, when I say capabilities, what do I mean for the most part? I pretty much primarily mean building skills. Skills are those reusable recipes we talked about that help you do things more efficiently. And so everything that I do on some sort of cadence, every time that I need to pull in my YouTube analytics, every time that I need to check in with the team, every time that I need to build a slide deck, all of those things I've built skills for in my AIOS. If I need to create images, if I need to create a LinkedIn post, All of these things are skills that I've built over time because I've challenged myself to do everything, to do as much as possible inside of my Claude Code. So building skills, building custom skills for your specific SOPs, your specific workflows, your specific tasks, remember how we talked about this thing earlier, every single task that you have can be broken up into chunks and all of these chunks and this overall larger thing can all be turned into a skill. So what I want you to do right now is I want you to grab a piece of paper and I want you to think about, It's a Monday morning. You wake up, you sit down at your desk, you're ready to do work. What do you do? Write down what you do on a Monday. And then unfortunately,

[1:07:30] pretend it's Tuesday. You go to your desk, write down what you do on Tuesday. As you do this throughout the week, as you do this at the end of each day, look at what you're doing. Circle things that are repeated, circle things that you see pop up consistently, circle things that you hate doing. And all of those things you circled are things that you should come into Claude Code with and say, Hey, I have this process. You know, Every Monday I have to organize all of the different tickets that we got over the weekend and I have to tag them and classify them. And then I have to route them to the right team. And then I have to follow up with them throughout the week. I hate doing that. Can you help me turn this into a skill? Sure. Let me ask you five or six questions to make sure I understand what you want. And let's build a skill together. And that is exactly how you start adding more and more capabilities into your agent. So in order to get a better understanding of skills, I'm going to go ahead and play a video where I break down a bunch of the ones that I use, how they work, and how you think about building them and improving them over time. It is super cool. It is the biggest unlock inside of an A.I.O.S. So I'll see you guys in that video. I have genuinely never been as productive as I am right now because of Claude's skills. This image really does sum it up. I feel like I'm working on multiple different computers and multiple different tasks at the same time without sacrificing quality. It just comes down to one simple word and that is leverage. with cloud skills or any agent skills for that matter, you have way more leverage than if you were doing this by yourself. So in this video, I'm gonna be breaking down what skills are, how they work, and how you can build really, really good ones, even if you've never heard of the concept or built a single skill ever before. So let's hop into a live demo real quick and get going.

[1:09:00] All right, so here we are in Claude Code in my Herc2 project, which is kind of just like my personal assistant. Now, if this stuff over here looks overwhelming, don't worry about that right now. Just worry on what I'm actually asking the agent to do. So I've got this skill that I called morning coffee that helps me plan my day every morning. So it's not morning right now, but I'm going to run this so you can see how it works. So as Claude Code's figuring that out, what I'm gonna do is open up another agent. And in this one, I'm asking it to run a pulse check on all my projects and commitments to see how things are going. I'm opening up another one to create me an Excal draw diagram of the difference between local AI models and closed source models. And let's just do one more that's gonna scrape the comments from my recent YouTube videos and give me an analysis on what I need to improve. So what you're looking at right now is four different agents running in parallel, doing things for me. And that took me probably 30 seconds to ask him to do that. And because I built all of these skills, all of these agents have all of the context about my business, what's going on with our projects, my YouTube channel, it has literally everything it needs. And now all of those agents are done. Here was my February 26 morning coffee. I had three things on the calendar. So what it's gonna do is it's gonna look at my click up. It's gonna see what else I've got this week and look at my tasks and then help me plan the rest of my day. So this is the plan that it suggested. All I'd have to do is say yep and it would block off everything for me. And for me, that's huge because I don't have decision fatigue anymore of what I have to work on. The second agent came back with a pulse check, two days until the end of the month, here's where everything stands. So obviously I'm gonna blur all of this out, but it's basically catching me up on all of the different main initiatives that we're doing this month and this quarter and making sure that everything is on track. And right here you can see there's a few things that I need to follow up on manually, and this might've slipped through the cracks because I'm so busy making YouTube videos

[1:10:30] if I didn't have this personal assistant to check up on me using this skill. The third agent came back and has finished the X-GALJAL diagram and I pasted it in and it looks like this. So if I needed to make a video about this, I wouldn't have had to take my own time to create this visualization. So for the comment analysis that came back and we can see all of the comments, all the views and things that I need to address either in future videos or in the comments. We've got some confusion, we've got some cost things that I need to cover. We have to stop demoing toy examples for tool videos. Seems like you guys really wanna see some anti-gravity stuff. I promise that'll come soon. And then we've got top three priorities. So I've been recording now this video for about six minutes. Just think about if I would have done all four of those things myself, how much context switching I would have done and how long that would have taken me. Okay, so now that you guys have seen an actual demo, and hopefully you're a little bit excited to learn about Cloud Skills if you haven't used them yet, what actually are they? So skills are reusable instructions. You write them once, you save them as a skill, you can trigger them anytime, and you're gonna get way more consistent results because it's going through that same process every time. So this visual right here was actually an AI generated image that I used with a skill. It was this one right here in my Claude Code called ExcaliDraw Visuals. But sometimes with AI generated images, they don't spell words right. As you can see here, this is all messed up. This stuff is messed up. So I also have one as you saw in the demo to create Excaljaw diagrams. And this one creates the actual Excaljaw that I could move and edit. And the words are always perfect because it's actually just typing. And those two skills alone have saved me so much time. And what I'm gonna do, by the way, for all you guys is in my free Skool community, the link for this is down in the description. I've added a new classroom session called Agent Skills,

[1:12:00] where I'm just gonna be dropping a ton of these skills that you guys can go grab for completely free. So before we dive into this today, just real quick, why should you care? And there's three big reasons. You can be way more productive as a person because you can automate things like you just saw me do. And you can legitimately build a personal assistant that can do almost anything for you. The second one is team leverage. So you can turn existing SOPs into automations really, really easy. And if you build something new, not just, you can use it, but your entire organization can, so everyone as a group is getting way more productive. Which will almost undoubtedly result in growth of the business. And also monetization. We're entering this new world where skills are having a big moment and you're able to capitalize on a lot of the stuff. Now I'm not saying this is going to be a viable business model for a long, long time, so you shouldn't bank on it, but it is something to be aware of, just like when people were selling and in workflow templates, things like that. But once again, it just comes down to one word, which is leverage. This isn't just theory, this is something that we're seeing with clients, this is something that we're seeing internally in my own business. This speed of work that we're able to achieve right now feels insane, but that is going to become normal. And if you can't do that, you instantly become way too slow and way too expensive for the business, and they might not keep you around. We're actually making it a priority to make sure all of our employees are using Claude Code, because now I have all these different skills that I can just run with a simple slash command or a simple natural language prompt and get in one day a week's worth of output. Because once again, one person can figure out the best way to do something and turn it into a skill that the entire team can use, but they don't just generate texts. They're basically automations. They can run scripts. They can call APIs and create things.

[1:13:30] They can have sub agents and they can be called on from agents as well. So this is truly AI automation. And just to really hammer it home. They're basically SOPs for your AI agents. The same way where you would train a human employee by letting them read through an SOP to understand the process, and then they'd be able to do it. You just train an agent on it. You give them the skill, they read it, and then they do it. And the coolest part about it is the more you use the skill, the better and better it gets. So we've talked about a lot of these benefits, right? But what actually is a skill? Well, it's just a folder, and it lives somewhere in your project. The most common example is probably going to be in your .claud slash skills slash skill name. and then you've got like a skill MD or a markdown file. So right here in my Herc 2 project, you can see up top we've got .CLOD. I open up .CLOD, we have agents, rules, and skills. Right now we're just talking about skills. If I open that up, we can see all of the different skills that I've created. So let's say for example the ExcalaDraw diagram diagram skill. If I click into that, we have a skill.md and when I open that up, you can see we have the name of the skill, the description, and then we have the actual workflow. Step 1, understand the concept. Step 2, plan the layout. Step 3, generate elements. And this entire skill basically teaches my agent how to build these Excalijaw diagrams for me. So like I said, that is the anatomy of the skill. We've got front matter, which is kind of between these two dotted lines. And that is in something called YAML, which you don't need to worry about what that means. This is just the way that it's kind of indicated sort of like your markdown or your Jason or Python. Now up here, we'll have a name and a description, which tells Claude code, what the skill is called and what the skill does.

[1:15:00] So as you can see, this one is called Excalijaw dash diagram. And there's a brief description about what it actually does or when to use it. And then we have the step-by-step rules, which are basically the instructions. And this is what Claude actually does. Once it decides that this is the right skill for the job. Now, the interesting thing about skills is that sometimes you need way more data. So for example, let's say we're writing a LinkedIn post. We have a skill for that, right? But what needs to go in the skill is other information. Sometimes like a company tone of voice, or maybe your LinkedIn, you know, tone a voice, a target avatar, current priorities, a logo, maybe there are other things that you want to put into a skill besides just like the step by step instructions that will make it better. So the question is, where do these things go? Well, there's typically two options, but essentially, as long as you're pointing to the right path in the skill.md, you're fine. So let me explain what I mean by that. And then I'll show you what I mean by that. So first option is to have it self contained. So in your dot cloud slash skills slash skill name, you can have the skill.md, You can have your scripts right there, and you can have your references right there. Or option B is that they're not directly nested right under that skill. So here we have .cloud slash skills slash infographic in the skill MD, and we still have our scripts and our references in the same project, but it's just not nested directly under that skill. And so I know that might've made no sense. So let me show you exactly what I mean by that. Okay, so here we have a skill called idea mining. And so what happens in here is basically use when someone asks for content ideas, video ideas, what to make next, or to run idea mining.

[1:16:30] And so in here, I gave it some context, right? My channel has this many subs, it's about AI automation. My content pillars are N8N, RAG agents, Claude Code, voice AI, and then...

[1:16:30] what I gave it is a bunch of references. I gave it channel data, which is youtube channel.md. I also gave it the raw data, which is a Jason file. I gave it a competitor list for me and I gave it an actual script to run analysis on my youtube channel. And so in this case, what you can see is that I went for option B where I'm storing those reference files on those scripts, not directly nested in this skill. So basically what it could look like is within the skill itself, we could have a folder called, you know, references. We could also have a folder in here called scripts. And then within both of these subfolders, we could have more things like, you know, in the references, I could have channel data. And in the scripts, I could have youtube-analysis.js or.py, whatever it is. Basically the idea is it doesn't matter where those actual reference files or scripts live, as long as you point to the right spot in the MD file. So in my case where these actually live is in a different folder. So here for the channel data, I would basically just go all the way down to references and then I could go down to right here youtube channel dot md. So Claude Code reads the skill and then it's able to find this if it needs it. Same thing for the scripts. It would go down here to scripts and then it would find analyze youtube dot py and it would just pull this in if it needed it. So hopefully you guys are with me however you want to set it up works. And I think that's the most overwhelming thing about Claude Code right now is that everyone uses different kind of

[1:18:00] folder architecture. But don't worry guys I'm totally on top of this. I have I have a skill that I built out called Skill Builder. And this one I'll be giving away for free once again in my free Skool community right here. And all you'd have to do is load in the Skill Builder and then it'll help you build out everything you need. And I'll be showing a live demo of that in a few minutes here. So the skill.md is the actual brain itself and the supporting files are the tools that it can use. That doesn't mean every single time the skill is invoked that those reference files will all be called. And just in case you guys were wondering if you've watched some of my previous Claude Code videos where we've used the WAT framework to build automations. This is very, very, very similar. In that framework, the W, the workflows, were the markdown file SOPs. That's basically the skill. The tools were the actual Python scripts, and that's basically just the scripts that you might write or the references that you would add in. So if you've already been building some WAT stuff, you will pick up skills super, super quickly. The cool thing about skills is that you don't have to build all of them. Obviously, as you're working with Claude Code and you're finding that you're doing things repetitively, you can go ahead and build a skill for it, but there's an official library from Entropic of skills, there's a community of everyone that's open sourcing their skills and giving them out. And there's a marketplace where you can share and sell or, you know, download skills from people. And then you would take that skill or that essentially a prompt and you would add your own flavor to it. The one thing I would say is just be careful and make sure that no one's trying to, you know, give you a skill that has any malicious intent in there. And all these skills can work across different products. So cursor, anti-gravity, codecs, because it's so based in Markdown and it's essentially just a prompt,

[1:19:30] tons of different AI models can use them. Okay, so how does Claude know when to use a skill? Well, there are two ways to actually trigger them. The first one is you can be explicit, which basically means you can do a slash command and say the skill name, and it will just directly fire off that skill, or it could just be natural language. So if I had a school post skill, I could say slash school-post, or I could natural language just say, hey, help me write a school post about X, Claude would find that skill and then invoke it. So when you ask Claude to do something, it will first read through the Claude.md file, It will analyze your request and it will search through the skills and see which one do I have that helps with this query. If it finds one, it will invoke it, but if it can't find anything, then it will basically just use its general knowledge. So not every single request that you give to Claude Code will invoke a skill. Now, a really important part of that is understanding how skills stay lightweight. Because if you've been using Claude Code, you know that context management is a huge deal. And if you had all of these skills to look through and all of these skills are, I don't know, hundreds and hundreds of lines, then if cloud was searching through all of these every single time, that would surely eat up a ton of your tokens. So what's used is something called progressive context loading, which basically means we have three levels. Level one is the initial search, where Claude Code only looks for the name and the description. So right here you can see, let's say we ask for an Excaljaw diagram. It would basically search through all the skills, but it would only read the YAML front matter. So it would read the name and the description. And typically this front matter is only going to be, you know, maybe roughly a hundred tokens. So it stays very lightweight. And then moving down to level two, let's say it identifies, okay, cool,

[1:21:00] this is the right skill for the job. Then it would run the full skill.md and it would read through everything. And so that's when it would start to actually understand what goes on in the skill. And that might be anywhere from a thousand to a couple of thousand tokens. And then level three is once again, a decision. Only load in the extra files when needed. So if I need to look at any scripts or references or templates, or I need to pull in some brand assets or more context, I'm only going to do that if their specific requests requires it. And so hopefully now you're starting to understand a little bit more about under the hood, what's actually going on when you ask Claude Code to do something for you. And you can always go to Claude Code Docs and go to the skills section and just read about how this stuff works. It's really, really simple. On the doc itself, it will tell you, just make sure to keep the skill.md under 500 lines, move detailed reference material to separate files. And so I know this may seem like it's just a lot of information being thrown at you. So let me just kind of contextualize this and slow it down and reassure you guys. You're never ever ever going to write a perfect skill the first try. The way that I build my skills is I have Claude Code do something with me. I walk it through the steps each time. And then when we're done, if we've went from point A to point B, I say, cool, this is something I do once a day. Let's turn this into a skill. Ask me more questions so we can make sure you have all the information you need. And once again, I'm going to show you guys opening up a brand new project and setting up a skill from scratch So you understand the full process, but I just had to give you guys some context first. Now we have this thing called the feedback cycle, which basically means you invoke the skill, you actually watch the agent work,

[1:22:30] you give feedback, and then it fixes the skill and then you do it again. And so the first couple of times you run a skill, you may feel like, eh, this feels very AI generated. But by the time you've run that skill 10, 20, 30 times, every single time, it gets better. And so that's why it's actually important to watch the agent work the first couple of times, because that's how you're able to identify opportunities to speed it up and save tokens by doing things like this. So here's an example of the pulse check skill that we actually ran earlier. Now this skill gets invoked when I ask for a pulse check or checking in on commitments. And what it does is it reads through some context of how OTAs work, which is important for it to understand every single time it reads this skill, which is why I put it here rather than a reference file. And what it has to do is it has to do a live lookup on my ClickUp to understand what's going on. So what I did is I hard coded, the these list IDs, because when I was watching it, I realized every single time it was doing this, it was calling the ClickUp MCP, and it was gathering all these lists and it was searching and parsing the results and then it would extract the ID and that just was taking so long and it was costing me a ton of tokens. So I realized that's always gonna be the same. Why don't I just give it in the skill document the list IDs? And now it knows how to do that instantly every time and it doesn't waste all those tokens. And on top of that, I know that searching through ClickUp can consume a lot of time and tokens. So I built a specialized sub-agent that in this skill I say, hey, delegate to the ClickUp searcher agent with this query in order to do, all of this searching so that you don't blow your own context window, all of that's handled over there. And then you only get the information that you need. So there's a lot of advanced things that you can do to manage your context. I'm not going to dive into all of that right now.

[1:24:00] We're just focusing on skills, but just wanted to give you a little taste of what's possible in the skill.md files. So another good example of needing a reference doc like that is in my skill builder skill. I obviously use this when I'm creating new skills, optimizing skills, auditing skill quality, things like that. And a lot of the inspiration I got from this was of course straight from Claude Code docs itself about how to actually use and build and optimize skills. And so when I was building this out, I was watching the agent run the skill and I realized it's searching every single time. It's doing a web search and it's crawling the entire document, even if I just need a little piece of information. So what I decided to do was I told it to basically scrape that whole thing and then I gave it a reference.md, which is basically the documentation. So I've got my skill.md and what it does is it references that full file if it needs it. But really the main idea that I'm trying to drive home here is that processing markdown files for your agent is so much quicker and cheaper than actually making API calls or HTTP requests, executing functions and reading tons and tons of tokens. So the goal is your skills will get to a place where you can invoke them, focus on something else for 10, 15 minutes or whatever, and then come back and have a finished result that is really, really good. But the first couple of times that you are testing out a skill, I think it's a really good idea to just sit there and watch it and see what it's doing. And a lot of people have asked me like, when do you know when to build a skill? Well, basically just go about your work. And if you ever realize that you've done something already, or you've instructed something differently, like I tell my Claude to not use MDashes. Okay. Well, that's probably a good idea to put that in the prompt, right?

[1:25:30] So if you ever find yourself doing a process or repeating prompts, then that's probably a good use case to build a skill around it because skills don't have to be complex. They could literally just be a 50 line markdown file. All right. So we're about to hop into a live build of a skill from scratch. But what I wanted to do real quick was go over the six step skill building framework. So number one is the name and the trigger. What is it called? And the natural language that would basically fire it off. Number two is the goal. So in one sentence, what will this skill accomplish by the end? What will be the output? Number three is the actual meat of it. That's the step-by-step process. If you had to do something manually, exactly what do you do and what order, what do you look at and what decisions do you make? Number four is the reference files. What context do you need? Do you need images? Do you need understanding of current projects, current priorities? Do you need style guides? What do you need to do the job well? Number five is the rules. Think about what could go wrong and then the agent can help you building guardrails and constraints around that. And then number six is kind of like after you've built it, it's just the self-improvement loop. And after the live build, I'm gonna talk about actually testing and iterating and what you need to do to make them really, really good. But for now, that's the six step skill building framework. Let's hop into a live build. Okay, so here we are in Visual Studio Code, which is where I like to use Claude Code. If you don't have Visual Studio Code, just go ahead to a browser, type in VS Code, and then go ahead and download this. This is what it will look like if it's your first time using Claude Code in here. You just have to go to Extensions on this left-hand side, type in Claude Code, and then install this, and then log in with your paid Anthropic subscription.