28:12Nate Herk | AI Automation · Tutorial
I asked Claude Code to make me as much money as possible
Four prompt-layer upgrades that fix the documented failure modes quietly killing your Claude output quality.
June 25thThe argument in one line.
Skills are reusable SOPs for AI agents — write the process once as markdown, and any compatible agent can execute it cheaper and more reliably each time you give it feedback.
Read if. Skip if.
READ IF YOU ARE…
- A solo operator or founder using Claude Code daily who keeps repeating the same multi-step prompts and wants to turn them into one-command automations.
- An engineering or ops lead at a small team trying to scale internal SOPs across the team without buying another SaaS workflow tool.
- A creator who already builds in n8n or with the WAT framework and wants to translate that mental model to Claude Code skills.
- Anyone evaluating whether to invest time learning Anthropic's skill format vs sticking with raw CLAUDE.md prompts.
SKIP IF…
- You have already shipped 5+ production skills and understand progressive context loading — most of the video is foundational.
- You're looking for security, sandboxing, or skill-versioning depth — those topics are deferred to the official docs.
- You want a comparison between Claude skills and OpenAI function calling or MCP tools — not covered.
The full version, fast.
A skill is a folder containing SKILL.md with YAML front matter and step-by-step instructions; optional scripts and reference files live alongside. Progressive context loading keeps cost low: Claude reads only the YAML to decide which skill applies, then loads the full SKILL.md, then loads reference files only if the skill asks. Build skills by watching the agent work the first few times, then giving feedback that gets baked into the markdown — by run 30 it executes the way you would, in seconds, for ~50 tokens. The six-step framework: name and trigger, one-sentence goal, step-by-step process, reference files, rules and guardrails, self-improvement loop. Skills are portable across Cursor, Codex, Copilot, and Gemini CLI, and global skills in ~/.claude/skills/ apply to every project.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.
00:00 – 02:41
01 · Intro and live demo
Four agents in parallel — morning coffee, project pulse check, Excalidraw diagram, YouTube comments analysis — to dramatize the leverage skills give a single operator.
02:41 – 03:35
02 · What are skills?
A skill is reusable instructions: write it once, save it as a skill, trigger it anytime, same result every time.
03:35 – 05:24
03 · Why you should care
Three reasons: personal productivity, team leverage, and a brief monetization window. The unifying word is leverage.
05:24 – 06:45
04 · Anatomy of a skill
A skill is a folder at .claude/skills/<name>/ containing SKILL.md with YAML front matter (name + description) and a step-by-step body.
06:45 – 11:00
05 · Reference files
Two options for supporting files: nested under the skill folder, or anywhere in the project as long as SKILL.md points at the right path.
11:00 – 13:17
06 · How Claude knows when to use a skill
Two trigger paths (explicit slash command vs natural language match on description) and the three-level progressive context loading that keeps it cheap.
13:17 – 17:13
07 · The feedback cycle and when to build a skill
Watch the agent work, give feedback, repeat — the skill compounds over 10-30 runs. Includes the ClickUp list-ID optimization as a concrete example.
17:13 – 18:10
08 · Six-step skill building framework
Name + trigger, one-sentence goal, step-by-step process, reference files, rules and guardrails, self-improvement loop.
18:10 – 22:54
09 · Live skill build
Nate uses his skill-builder skill to author an infographic-builder skill that calls Kie.ai Nano Banana, overlays the AIS logo, and produces 1:1 PNG infographics. Iterates once on feedback.
22:54 – 23:55
10 · Testing the skill and iterating on results
Symptom-to-fix mindset: bridging the gap from a 90%-good skill to one that produces consistent output by run five or six.
23:55 – 26:57
11 · Testing, debugging, and common fixes
The debugging matrix — wrong order edits SKILL.md, missing context adds a reference file, repeated mistake adds a rule, etc. Plus front-matter advanced fields.
26:57 – 27:18
12 · Project vs global skills and outro
Project skills (.claude/skills/) vs global skills (~/.claude/skills/). Soft CTA to Skool community for the free skills.
Lines worth screenshotting.
- A skill is just a folder with a markdown file — the entire format is YAML front matter (name + description) plus a step-by-step body.
- Progressive context loading is what makes skills cheap: Claude reads only the ~100-token YAML front matter to decide which skill to load, not the full body.
- By the time you've run a skill 30 times it stops feeling AI-generated and starts feeling like you — the compounding only happens if you give feedback after each run.
- Watching the agent execute is the highest-leverage debugging move: Nate saved ~450 tokens per invocation by hard-coding ClickUp list IDs after seeing the agent search for them every time.
- If a skill struggles with a tool or MCP, write a tool-reference markdown file instead of letting the agent re-discover the tool surface every run.
- Skills are basically SOPs for AI agents — the same process you'd hand a new hire on day one is the process you hand the agent.
- Skill marketplaces are a real-but-fading monetization window, comparable to n8n template marketplaces — capitalize now, don't bank on it as a long-term business model.
- Global skills live in ~/.claude/skills/ and apply to every project; project skills live in <project>/.claude/skills/ and apply only there.
- The same markdown skill format works in Cursor, Codex, Anti-Gravity, Copilot, and Gemini CLI — it's just a prompt with structured front matter.
- If a skill triggers too often, set disable_model_invocation: true so it only fires when called by an explicit slash command.
- Reference files don't have to live nested under the skill folder — as long as SKILL.md points at the right path, they can live anywhere in the project.
- Anthropic recommends keeping SKILL.md under 500 lines — anything longer should be split into reference files loaded on demand.
- The right time to build a skill is the second time you notice yourself doing the same multi-step process or correcting the agent in the same way.
- A skill can run scripts, call APIs, create files, and delegate to sub-agents — it isn't just a prompt template, it's an automation primitive.
How to make Claude Code skills that compound.
WHAT TO LEARN
Skills are SOPs for AI agents — they only become valuable when you watch them run, give feedback, and let progressive context loading keep them cheap as you accumulate dozens.
- Open Claude Code, type /<skill-name>, and the agent reads only the YAML front matter to decide which skill to load — keep that description specific or natural-language triggering won't fire.
- Drop new skills in <project>/.claude/skills/<name>/SKILL.md for project-only, or ~/.claude/skills/<name>/SKILL.md for global access across every project on your machine.
- When the agent does the same wasteful step twice in a row, hard-code the answer into SKILL.md — Nate cut ClickUp list lookups from 500 tokens and 5 seconds to 50 tokens and instant by pasting the IDs directly.
- Use the six-step framework when authoring: name and trigger, one-sentence goal, step-by-step process, reference files, rules and guardrails, self-improvement loop.
- Keep SKILL.md under 500 lines per Anthropic's guidance — anything longer should be split into reference files loaded only when SKILL.md explicitly points at them.
- Build a skill-builder skill that interviews you about the new skill, generates the SKILL.md, registers it in CLAUDE.md, and logs the decisions — you'll never hand-write skill markdown again.
- When a skill triggers too aggressively, add disable_model_invocation: true to the YAML so it only fires on the explicit slash command and stops hijacking unrelated prompts.
- Test a new skill by running it five to six times back-to-back and giving feedback after each run — that's how it crosses from 90% useful to consistently shippable.
- Treat community marketplaces (SkillMP, official Anthropic library) as a starting point, but always vet the markdown for malicious instructions before installing.
- The skill format is portable — the same SKILL.md works in Cursor, Codex, Anti-Gravity, Copilot, and Gemini CLI, so you're not locking into any one IDE.
Terms worth knowing.
- Skill
- A folder containing a SKILL.md markdown file (with YAML front matter) plus optional scripts and reference files, defining a reusable workflow Claude Code can invoke by slash command or natural language.
- Progressive context loading
- Anthropic's three-tier system for loading skills cheaply: front matter only at startup, full SKILL.md when triggered, supporting files only when explicitly referenced.
- YAML front matter
- The metadata block at the top of a SKILL.md file (between two --- lines) containing the skill's name, description, and optional advanced fields like disable_model_invocation and allowed-tools.
- Disable model invocation
- A front-matter setting that prevents Claude from auto-selecting a skill based on natural language, forcing it to only fire on an explicit slash command.
- Skill builder
- A meta-skill that interviews you about a new skill you want to build, then generates the SKILL.md, registers it in CLAUDE.md, and logs the decisions — letting you author skills conversationally instead of writing markdown by hand.
- WAT framework
- Nate's prior naming for an automation pattern (Workflows + Agents + Tools) that maps cleanly onto skills: workflows become SKILL.md, tools become scripts, agents become sub-agent calls.
- Feedback cycle
- The iterative loop of running a skill, watching the agent execute, identifying inefficiencies or errors, and updating SKILL.md so the next run is cheaper and more accurate.
- Sub-agent delegation
- Calling a specialized agent from inside a skill to perform a token-heavy subtask (e.g., searching ClickUp) so the main agent's context window stays clean.
Things they pointed at.
03:27channelNate's free Skool community (agent skills classroom)
09:40toolAnthropic official skills library
09:40toolSkillMP marketplace
19:00toolVisual Studio Code
19:00toolClaude Code VS Code extension
20:30toolKie.ai (Nano Banana image API)
10:00toolClickUp + ClickUp MCP
06:00toolExcalidraw
12:50linkClaude Code docs — Extending Claude with Skills
27:00channelNate Herk paid community
Lines you could clip.
00:00
“I have genuinely never been as productive as I am right now because of Claude's skills.”
00:24
“It just comes down to one simple word and that is leverage.”
04:20
“This speed of work will become normal, and if you can't do it, you instantly become way too slow and way too expensive for the business.”
08:00
“Skills are basically SOPs for AI agents.”
13:35
“You're never ever ever going to write a perfect skill the first try.”
15:05
“Every single time you correct the skill, it gets permanently smarter. That mistake never happens again. That's the compound effect.”
16:55
“Skills don't have to be complex — they could literally just be a 50-line markdown file.”
26:50
“The same skill format works in Cursor, Codex, Anti-Gravity, Copilot — because it's so based in markdown and it's essentially just a prompt, tons of different AI models can use them.”
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
metaphoranalogy
00:00I 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 without sacrificing quality.
00:10It just comes down to one simple word and that is leverage. With Claude's 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.
00:27So let's hop into a live demo real quick and get going. Alright. So here we are in Claude code in my Herc two project which is kind of just like my personal assistant.
00:35Now 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.
00:44So it's not morning right now, but I'm going to run this so you can see how it works. So as Cloud 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.
00:56I'm opening up another one to create me an Excalidraw 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 thirty seconds to ask them to do that.
01:14And 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.
01:23Here 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 ClickUp. 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.
01:34So this is the plan that it suggested. All I'd have to do is say yep, 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.
01:41The 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.
01:54And right here, can see there's a few things that I need to follow-up on manually, and this might have slipped through the cracks because I'm so busy making YouTube videos 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 Excalidraw diagram, and I pasted it in and it looks like this.
02:08So 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 comments 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. Got some confusion.
02:21We'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.
02:29I 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.
02:34Just 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?
02:48So 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.
03:02It was this one right here in my cloud code called Excalidraw visuals. But sometimes with AI generated images, they don't spell words right.
03:09As 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 Excalidraw diagrams.
03:16And this one creates the actual Excalidraw 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 school community, the link for this is down in the description, I've added a new classroom section called agent skills where I'm just gonna be dropping a ton of these skills that you guys can go grab for completely free.
03:35So 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.
03:52And 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.
04:04We'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 edit and workflow templates and things like that.
04:18But 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.
04:24This 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.
04:31And 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 Cloud 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.
04:48Because 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 text. They're basically automations.
04:57They can run scripts. They can call APIs. They can create things.
04:59They 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.
05:08The 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.
05:18And 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?
05:23But 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 dot Claude slash skills slash skill name, and then you've got, like, a skill MD or a markdown file.
05:37So right here in my Herc two project, you can see up top we've got dot Claude. I open up dot Claude. We have agents, rules, and skills.
05:44Right now, we're just talking about skills. If I open that up, we can see all of the different skills that I've created in it. So let's say, for example, the Excalidraw diagram skill.
05:52If I click into that, we have a skill dot m d. 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 one, understand the concept.
06:00Step two, plan the layout. Step three, generate elements. And this entire skill basically teaches my agent how to build these Excalidraw diagrams for me.
06:08So 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 JSON or Python.
06:24Now up here, we'll have a name and a description, which tells Claude code what the skill is called and what the skill does. So as you can see, this one is called Excalidraw 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.
06:39And 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.
06:51We 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 of voice, a target avatar, current priorities, a logo maybe.
07:03There are other things that you wanna 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 dot m d, you're fine.
07:18So 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 claud slash skills slash skill name, you can have the skill dot m d.
07:28You can have 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 dot Claude slash skills slash infographic in the skill m d, and we still have our scripts and our references in the same project, but it's just not nested directly under that skill.
07:46And so I know that might have made no sense, so let me show you exactly what I mean by that. Okay. So here we have a skill called idea mining.
07:52And so what happens in here is basically used when someone asks for content ideas, video ideas, what to make next, or to run idea mining. And so in here, gave it some context. Right?
08:01My channel has this many subs. It's about AI automation. My content pillars are n eight n, Rag Agents, Cloud Code, Voice AI.
08:08And then what I gave it is a bunch of references. I gave it channel data, which is youtubechannel.md. I also gave it the raw data, which is a JSON file.
08:16I 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 So basically what it could look like is within the skill itself, we could have a folder called, you know, references.
08:37We 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.
08:47And in the scripts, I could have youtube-analysis.js or .py, whatever it is.
08:52Basically, 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, youtubechannel.md.
09:10So 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.py, and it would just pull this in if it needed it.
09:22So hopefully you guys are with me. However you wanna set it up works. And I think that's the most overwhelming thing about Cloud Code right now is that everyone uses different kind of folder architecture.
09:30But don't worry, guys. I'm totally on top of this. I have a skill that I built out called skill builder.
09:35And this one, I'll be giving away for free once again in my free school 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.
09:46So 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.
09:56And just in case you guys were wondering, you've watched some of my previous Cloud 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.
10:08That'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.
10:19The cool thing about skills is that you don't have to build all of them. Obviously, as you're working with Cloud Code and you're finding that you're doing things repetitively, you can go ahead and build a skill for it.
10:27But there's an official library from Anthropic 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.
10:43The 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, antigravity, codex.
10:55Because it's so based in markdown and it's essentially just a prompt, tons of different AI models can use them. Okay.
11:01So 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.
11:14So if I had a school post skill, I could say slash school dash post, or I could natural language just say, hey. Help me write a school post about x. Cloud would find that skill and then invoke it.
11:24So when you ask Cloud to do something, it will first read through the Cloud dot m d 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.
11:34If 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 Cloud Code will invoke a skill.
11:42Now a really important part of that is understanding how skills stay lightweight. Because if you've been using Cloud 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 Code was searching through all of these every single time, that would surely eat up a ton of your tokens.
12:01So what's used is something called progressive context loading, which basically means we have three levels. Level one is the initial search where ClaudeCode only looks for the name and the description. So right here, you could see let's say we ask for an ExcalJaw diagram.
12:14It 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 100 tokens, so it stays very lightweight.
12:26And then moving down to level two, let's say it identifies, okay. Cool. This is the right skill for the job.
12:30Then it would run the full skill dot m d, 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 thousand tokens. And then level three is once again a decision.
12:45Only 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 request 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.
13:04And 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 dot m d under 500 lines.
13:15Move 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.
13:29The way that I build my skills is I have Cloud Code do something with me. I walk it through the steps, you know, each time. And then when we're done, if we've went from point a to point b, I say cool.
13:39This 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.
13:45And 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, you give feedback, and then it fixes the skill, then you do it again.
14:02And so the first couple times you run a skill, you may feel like, this feels very AI generated. But by the time you've run that skill ten, twenty, 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.
14:21So 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.
14:36And 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 in 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.
14:54And 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?
15:03And 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.
15:22All 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.
15:29We're just focusing on skills, but just wanted to give you a little taste of what's possible in the skill dot m d 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.
15:45And a lot of the inspiration I got from this was, of course, straight from ClaudeCode docs itself about how to actually use and build and optimize skills. And so when I was building this out, I I was watching the agent, you know, run the skill and I realized it's searching every single time.
15:59It'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 dot m d, which is basically the documentation. So I've got my skill dot m d, and what it does is it references that full file if it needs it.
16:16But, 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, you know, 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 ten, fifteen minutes or whatever, and then come back and have a finished result that is really, really good.
16:39But the first couple 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, go about your work.
16:51And if you ever realize that you've done something already or you've instructed something differently, like I tell my Claude to not use Emdashes. Okay. Well, that's probably a good idea to put that in the prompts.
17:00Right? 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.
17:09They could literally just be a 50 line markdown file. Alright. 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.
17:19So number one is the name and the trigger. What is it called and the natural language that would basically fire it off?
17:26Number two is the goal. So in one sentence, what will this skill accomplish by the end? What will be the output?
17:31Number 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 in what order, what do you look at, and what decisions do you make?
17:40Number four is the reference files. What context do you need? Do you need images?
17:44Do you need understanding of current projects, current priorities? Do you need style guides? What do you need to do the job well?
17:50Number 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.
17:58It'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.
18:08Let's hop into a live build. Okay. So here we are in Visual Studio Code, which is where I like to use Cloud Code.
18:13If you don't have Visual Studio Code, just go ahead to a browser, type in Versus Code, and then go ahead and download this. This is what it will look like if it's your first time using Cloud Code in here. You just have to go to extensions on this left hand side, type in Cloud Code, and then install this, and then log in with your paid Anthropic subscription.
18:30After that, you're gonna click on this top left button and it's gonna pull up this little thing that says you have not yet opened a folder. What you need to do is open up a project to work in. So you can either open up one that you're already working on or you could go ahead and create a new folder and then open that one up.
18:42For the sake of the demo, I just opened up a new blank folder called a bunch of skills, and I'm gonna show you exactly what to do. So the first step is to go to my free school community, link in the description, go to the agent skills classroom, and download the skill builder folder.
18:55Once you've got those files ready to go, first thing we wanna do is just set up this workspace real quick. Initialize this project with a simple dot Claude slash skills structure. Cool.
19:06So as you can see, that got set up. We have a dot Claude. We have a skills folder.
19:10And what I'm gonna do is in this skill folder, I'm gonna create a new folder called skill dash builder and hit enter.
19:17And then I'm gonna take those two files from my school community, the reference and the markdown, and I'm gonna put that right in here. So now we have this skill builder set up with the reference file and the actual skill markdown. I'm asking it if it can see that new skill that I just added.
19:31It says, yes. I can see it, and I'm basically just gonna say, cool. Let's run that skill to build a new one together.
19:36So now you can see what it did is it basically is reading the skill right now. This is the instructions that we saw right in here as you guys know since that's how skills work. It starts to read this.
19:46So here we go. I built this skill to actually ask you questions so that it's way easier for you to communicate what you want. So the first thing is what problem are you trying to solve?
19:53What we wanna do is content creation. Because in this skill, what I wanna do is building branded infographics. What kind of content does the skill create?
20:01What's the specific use case or workflow? And I'm actually just gonna choose other for this, and I'm gonna say educational infographics. Now it's asking how we should trigger this skill.
20:08So does it wanna be natural language, or do we wanna just use slash commands? And I'm just gonna say both is fine. And now we're moving on to the step by step process, which is really important because at this point, we haven't told it what tech stack we actually wanna use or anything else about our business.
20:22So walk me through what should happen from trigger to output. And it has some good guesses, but what I'm gonna do is do other and explain this the way that I want it built. I will tell you what I want an infographic about.
20:32You will create a concept. You will make a request to Key dot a I to use Nano Banana to generate the outline or sorry, to generate the image, and you will also look at the brand guidelines that I give you so that everything that is created follows my brand colors and typography and stuff like that.
20:50The output format that I actually want is a PNG, not any of this stuff. Does this need to be conversational or fire and forget? I'm just gonna go fire and forget.
20:58Alright. So how does the KeyAI NanoBanana integration work? Is it an API call?
21:02Yep. We're just gonna go with an API call. And in these options, you could literally say, I don't know.
21:06Let's try different things. You know, help me figure out what's best. It's asking where those brand assets live, so I'll put them in a folder.
21:12And where should the generated PNG infographic be saved? Yeah. Sure.
21:15Let's start a new folder called projects, and we'll throw all of them there. So it's gonna keep our project organized as well. So now it's asking about brand guidelines.
21:22I created this folder, and I put in our kind of color scheme as well as the actual AIS logo. I have put in both our AIS brand guidelines and the AIS logo. I wanna make sure that in the top left corner of every single infographic that's created, the AIS logo appears exactly as I've given you.
21:39But I think you guys get the point here. I'm gonna answer a few more questions, and then I'll just show you when we have a result. And now that we've done that, what you can see is it is going to create the skill.
21:48It's going to create the logo overlay. It's gonna create a supporting reference markdown file for all of the API details that it's gonna need. So that's great.
21:55It's gonna register the skill in claw.md, and it's going to log its decisions. Alright.
22:00So it fully built the skill. It created all those files for us. We just have to give it a key API key so it can actually run this.
22:07Okay. So I threw in my API key, and then I said test it out with an infographic about Claude skills. That's it.
22:12No other context. It invoked the skill right here, and we will see what happens. Okay.
22:17This is really interesting. So what it's doing is it is generating the image, and then it's just going to overlay the logo. So it's gonna be a lot more consistent than giving the AI image generator, Nano Banana, my logo.
22:27I didn't even tell it to do that. Let's see how it looks. Okay.
22:30Well, I don't love this. We're just gonna go back and ask it to change some things. The logo on the top left doesn't look great.
22:36I gave you a logo with a transparent background, so it should just be overlaid on top, we should be able to see the background behind it. The actual infographic itself is alright, but I actually want these to always be one by one aspect ratio. Okay.
22:50So I made some suggestions, and it's gonna try again, and it's gonna update its skill. So we'll see if that's better. Alright.
22:55So second time we run the skill, let's see if it's any better. Alright. There we go.
22:58We've got the logo up top. We've got cloud code skills, custom AI workflow, command prompt trigger, front matter config, triggers, AI agent delegation, document output.
23:07So just keep in mind, all we said was build an infographic about cloud skills. And this was run number two. Every single time that we do this cycle, remember we talked about the feedback, we would basically watch it again, give more feedback, and then keep going.
23:20And after we run this probably five or six more times, this would be really really good, and then every time I ask for an infographic, it's going to be consistent. And just to show you guys what was actually built, if we open up the infographic builder skill, we have the actual skill itself.
23:32So we have the front matter right here, the name, the description. We've got what the skill does. We've got context.
23:38So here's where it links to the actual brand guidelines and logos. We've got the step by step workflow right here. And we can see right here for full API reference and parameters, just see the markdown file that you don't have to actually go search the web and search through a bunch of tokens.
23:52You can just read this markdown file. Alright. So we've talked about a lot of stuff about skills today, and we just built one live.
23:57So what I wanna talk about now is really how do you bridge the gap from, like, a 90% good skill to making it pretty much a 100%. So testing, iterating, and debugging. There's different symptoms and there's different fixes.
24:08So let's just kinda go down this list one by one. The first symptom might be it does the wrong steps or in the wrong order. Well, you would just tell it to edit the skill.md instructions.
24:17You could get missing tone, style, or context. In that case, you're going to add reference files. And, of course, those have to be pointed to correctly in the skill dot m d.
24:25You could get the same mistake happening over and over, then you're gonna add a rule. If it struggles with a tool or an MCP or it keeps searching for the same things, then create some sort of reference doc for it. If it works good but it could get better, then that just means you have to brute force it, you have to just run it over and over and over and keep nitpicking at what it does wrong.
24:42Or maybe not wrong, but what it could improve on. If the skill isn't triggering, then check the YAML and make sure it is specific enough. If the skill triggers too often, then maybe try disabling model invocation.
24:52And that is something that you can see in the claw docs, which basically gives you control over if the skill can only be invoked by natural language or only be invoked by the slash command directly or both. So like I said, if you wanna look at some more advanced stuff, then definitely head over here to the actual doc. But at this point, we've covered almost everything about these skills.
25:08One thing that I would call your attention to is the actual front matter reference because we saw the name and the description, which is what's required every time, but there's lots of other things that you can add in there. Here's the disable model invocation like we just saw, but you can also give it allowed tools. You can also give it an argument hint.
25:24You can give it a specific model to use. You can give it a specific context. You can give it hooks.
25:28You can give it a specific agent. And so all of this lets you get really, really granular on the exact skill and how you want it to be used. But don't get overwhelmed.
25:36You really only get to that point once you've ran the skill a ton of times. Now another thing that I need to hit on real quick is where do skills actually live? Because what we've seen so far is just building them right in our dot cloud slash skills folder.
25:47But when you're doing this, they only exist in that specific project. So whether that's my hart two or my, you know, the one we just spun up, if I went to a different folder, that skill would no longer be able to be accessed by Cloud Code. But you can also create skills that are actually global, and you do that by doing that in a different directory, in your kind of overall home directory, and that's basically indicated by the little tilde right here.
26:09And so that means every product you use in Cloud Code, no matter where you are, that skill would exist. So for example, I have a front end design skill that is installed globally so that whenever I'm anywhere, if I need to do front end design, it just is able to use it.
26:23And just in case you wanna look at it in a different way, right now what we're doing is we have our projects. Right? So Herc two.
26:29And then we have dot cloud, and then within dot cloud, we have skills and then your skill and then your MD, your references, whatever, and then maybe another skill. But if it was global, you might not actually see it in your project.
26:40It would just be within your overall home directory. So the reason why you might wanna do this is if there's something very specific about you, your business, your workflows that you want applied to every single project no matter what, maybe your company context, your company projects, your tone of voice, whatever, then you can install that globally instead.
26:56If you guys love nerding out about this kind of stuff, then definitely check out my paid community. The link for that is also down in the description. We've got a great community, over 3,000 members in here who are building with AI every day and building businesses with AI.
27:07I'd love to see you guys in this community. But that's gonna do it. So if you learned something new, please give it a like.
27:11It definitely helps me out a ton. And as always, I appreciate you guys making it to the end of the video. I will see you on the next one.
27:17Thanks, everyone.
The Hook
The bait, then the rug-pull.
Open the video and the first thing you see is Nate at a desk with six monitors and a caption that reads "Me with Claude Skills." The joke lands because the rest of the video earns it — by the four-minute mark he has four Claude Code agents executing four unrelated workflows in parallel, all because each one is wrapped in a skill.
Named ideas worth stealing.
17:13list
Six-step skill building framework
- Name and trigger — what is it called and what natural language fires it
- Goal — one sentence describing the end output
- Step-by-step process — the exact workflow with decision points
- Reference files — context, style guides, brand assets
- Rules — guardrails against likely failure modes
- Self-improvement loop — feedback-driven iteration
Nate's canonical structure for designing a skill from scratch.
Steal forany internal SOP-to-automation conversion project
12:00model
Progressive context loading
- Level 1 (startup): YAML front matter only — name + description, ~100 tokens per skill
- Level 2 (triggered): full SKILL.md loaded — ~1k-3k tokens
- Level 3 (on demand): supporting files loaded only when SKILL.md references them
The token-budget mechanism that lets you keep dozens of skills installed without bloating context.
Steal fordesigning any agent system that needs to scale to many specialized capabilities
23:55list
Skill debugging matrix
- Wrong steps or wrong order → edit SKILL.md instructions
- Missing tone, style, or context → add a reference file
- Same mistake every time → add a rule
- Struggles with a tool or MCP → create a tool reference doc
- Works but could be better → brute-force run 5+ more times
- Skill not triggering → check YAML description specificity
- Skill triggers too often → set disable_model_invocation: true
Symptom-to-fix matrix for diagnosing a misbehaving skill.
Steal fora runbook for any team standardizing on Claude Code skills
10:00concept
WAT-to-skill translation
If you've built with the WAT framework (Workflows + Agents + Tools), skills map cleanly: workflows become SKILL.md, tools become scripts, agents become sub-agent delegations.
Steal forn8n / automation builders migrating mental models to Claude Code
How they asked for the click.
VERBAL ASK
27:00newsletter
“If you guys love nerding out about this kind of stuff, then definitely check out my paid community. The link for that is also down in the description.”
Soft, under 20 seconds, no urgency. Two-tier: free Skool for the skills, paid Skool for the community. Conversion-friendly because the free tier is genuinely useful.
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
AFFILIATECommission earned if you click.
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
