Claude Code Skills Are Broken (Beginner to Pro)

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 Claude 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 going to 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. All right, so

here we are in Claude Code in my Herk 2

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 the 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 Cloud

Code's figuring that out, what I'm going

to 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

diagram of the difference between local

AI models and closed source models. And

let's just do one more that's going to

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 them 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 26th morning

coffee. I had three things on the

calendar. So, what it's going to do is

it's going to look at my ClickUp. It's

going to 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 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, 2 days until the end

of the month. Here's where everything

stands. So, obviously I'm going to 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 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 the skill. The third agent came

back and has finished the Excal 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 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 want

to 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

6 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 going to 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 Cloud Code

called Excalibraw 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 Excalaw

diagrams. And this one creates the

actual Excal 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 going to 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 going to 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

this 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 edited in workflow templates and

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 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. 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 text. They're basically

automations. They can run scripts. They

can call APIs. They can create things.

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.claude/skills/skillname

and then you've got like a skill MD or a

markdown file. So, right here in my Herk

2 project, you can see up top we've

gotclaude. I open up.claude, we have

agents, rules, and skills. Right now,

we're just talking about skills. If I

open that up, we can see all the

different skills that I've created in.

So, let's say for example, the Excal

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 one,

understand the concept. Step two, plan

the layout. Step three, generate

elements. And this entire skill

basically teaches my agent how to build

these Excal 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 JSON 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. So, as you can see, this one

is called Excalraw- 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 of 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.mmd, 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

yourcloud/skills/skll

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.claude/skill/infographic

Claude/skill/infographic

in the skillmd 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 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 and 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 I gave it some context right my

channel has this many subs it's about AI

automation my content pillars are naden

rag agents cloud odd code, voice AI, and

then 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 JSON 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 and 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.md. So cloud

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. 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

cloud code right now is that everyone

uses different kind of folder

architecture. But don't worry guys, I'm

totally on top of this. I have a skill

that I built out called skilluer. And

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. 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 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. 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 cloud 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 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. 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, codeex, because

it's so based in markdown and it's

essentially just a prompt, 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

slashschool-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 cloud. 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 cloud code will invoke

a skill. Now 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. So

what's used is something called

progressive context loading which

basically means we have three levels.

Level one is the initial search where

cloud code only looks for the name and

the description. So right here you can

see let's say we ask for an Excal

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 100

tokens. So it stays very lightweight.

And then moving down to level two let's

say it identifies okay cool this is the

right skill for the job. Then it would

run the full skill.mmd 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. 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

the 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 cla code to do something for

you. And you can always go to cloud 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, you know, 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, you

give feedback, and then it fixes the

skill, and then you do it again. And so,

the first couple 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

OTAAS work, which is important for it to

understand every single time it reads

the 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

hardcoded 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 and that

just was taking so long and it was

costing me a ton of tokens. So I

realized that's always going to 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. 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 I was watching the agent, you

know, 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, 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

10, 15 minutes or whatever, and then

come back and have a finished result

that is really, really good. But 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

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 m dashes. Okay, well that's

probably a good idea to put that in the

prompt, right? 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 50line

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 in 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 build in

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 going to talk about

actually testing and iterating and what

you need to do to make them really,

really good. But for now, that's the

sixstep 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 Cloud 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 cloud code in here, you

just have to go to extensions on this

lefth hand side, type in cloud code, and

then install this and then log in with

your paid anthropic subscription. Now,

after that, you're going to click on

this top left button, and it's going to

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 could 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. For the sake

of the demo, I just opened up a new

blank folder called a bunch of skills.

And I'm going to 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 skilluer

folder. Once you've got those files

ready to go, first thing we want to do

is just set up this workspace real

quick. Initialize this project with a

simple.cloud/skills

structure. Cool. So, as you can see,

that got set up. We have aclad. We have

a skills folder. And what I'm going to

do is in this skill folder, I'm going to

create a new folder called skill dash

builder and hit enter. And then I'm

going to take those two files from my

school community, the reference and the

markdown, and I'm going to 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. It says yes, I can

see it. And I'm basically just going to

say, cool, let's run that skill to build

a new one together. So 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. So,

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? What we

want to do is content creation because

in this skill, what I want to do is

building branded infographics. What kind

of content does the skill create? What's

the specific use case or workflow? And

I'm actually just going to choose other

for this. And I'm going to say

educational infographics. Now, it's

asking how we should trigger this skill.

So, does it want to be natural language

or do we want to just use slash

commands? And I'm just going to 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 text we actually

want to use or anything else about our

business. So, walk me through what

should happen from trigger to output.

And it has some good guesses. But what

I'm going to do is do other and explain

this the way that I want it built. I

will tell you what I want an infographic

about. You will create a concept. You

will make a request to key.ai AI 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. The

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 going to go fire and

forget. All right. So, how does the Key

AI Nano Banana integration work? Is it

an API call? Yep, we're just going to go

with an API call. And in these options,

you could literally say, I don't know.

Let'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. And where

should the generated PNG infographic be

saved? Yeah, sure. Let's start a new

folder called projects. And we'll throw

all of them there. So, it's going to

keep our project organized as well. So,

now it's asking about brand guidelines.

I 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

want to 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. But I think

you guys get the point here. I'm going

to 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. It's going to create

the logo overlay. It's going to create a

supporting reference markdown file for

all of the API details that it's going

to need. So that's great. It's going to

register the skill in claw.md and it's

going to log its decisions. All right,

so it fully built the skill. It created

all those files for us. We just have to

give it a key API key so we can actually

run this. Okay, so I threw in my API key

and then I said test it out with an

infographic about cloud skills. That's

it. No other context. It invoked the

skill right here and we will see what

happens. Okay, this 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 going

to be a lot more consistent than giving

the AI image generator Nano Banana my

logo. So I didn't even tell it to do

that. Let's see how it looks. Okay.

Well, I don't love this. We're just

going to go back and ask it to change

some things. The logo on the top left

doesn't look great. I gave you a logo

with a transparent background, so it

should just be overlaid on top and we

should be able to see the background

behind it. The actual infographic itself

is all right, but I actually want these

to always be one by one aspect ratio.

Okay, so I made some suggestions and

it's going to try again and it's going

to update its skill. So, we'll see if

that's better. All right, so second time

we run the skill. Let's see if it's any

better. All right, there we So, we'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. So, 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. And 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. So we have the

front matter right here, the name, the

description, we've got what the skill

does. We've got context. So 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

so that you don't have to actually go

search the web and search through a

bunch of tokens. You can just read this

markdown file. All right. All right, so

we've talked about a lot of stuff about

skills today and we just built one live.

So what I want to talk about now is

really how do you bridge the gap from

like a 90% good skill to making it

pretty much 100%. So testing, iterating,

and debugging. There's different

symptoms and there's different fixes. So

let's just kind of 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. You

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. MD. You could get the same

mistake happening over and over, then

you're going to 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 dock

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, or

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. And 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 want to 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. One 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. You can give it a

specific model to use. You can give it

specific context. You can give it hooks.

You 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. You 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

ourcloud/skills folder. But when you're

doing this, they only exist in that

specific project. So whether that's my

her 2 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 our 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

tilda right here. And 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. And just in case

you want to look at it in a different

way, right now what we're doing is we

have our projects, right? So herk 2 and

then we havecloud and then within

dotcloud 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. It

would just be within your overall home

directory. So the reason why you might

want to 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. 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. We've got a great

community, over 3,000 members in here

who are building with AI every day and

building businesses with AI. So, I'd

love to see you guys in this community.

But that's going to do it. So, if you

learned something new, please give it a

like. It 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. Thanks

everyone.