Let it Cook - Agent Skills aka Skills.md in VS Code

[music] [music] [music] Woohoo! [music]

Woohoo! [music] Heat!

Woo!

[music] [music] [music] [music] Woo!

Woo!

[music] [music] Woo!

[music] [music] >> [music] >> Welcome back everyone to the holiday edition of Let It Cook. This is our last cooking of the year. We took a little break from cooking, but we are back.

This is the show here on the VS Code channel where we break down all the latest in agentic development inside of your favorite code editor, VS Code. We

have folks all around the globe coming in and Jonas hates the intro music and we're going to totally fix it one day for sure. That is for sure. People from

for sure. That is for sure. People from

all over the place tuning in. I am super excited today because the team and the community just dropped agent skills all over the place and I have two of the

most amazing people in the entire world with me today to break it all down. Mr.

Harold and Tim, how's it going guys?

>> Hey, how's it going?

>> It is going great. We have our holiday thing happening and and I don't I I love it and I and [laughter] I I'm not sure how I feel about it, but I love it. We'll get rid of it. Don't

worry. We'll go back to some classic streams. So, we have like tropical snow.

Oh, you can't even see the tropical snowman. Let's see. We'll pull that

snowman. Let's see. We'll pull that some. We have like cozy night back here.

some. We have like cozy night back here.

Wow, this is great. We have this Streamyard just going crazy with the stuff. So, uh Oh, we have a boxing day.

stuff. So, uh Oh, we have a boxing day.

That seems like something I don't know what that is, but that sounds great.

Sounds like something maybe Tim knows about.

>> Don't worry about it. [laughter]

>> Holiday. All right, we'll go back to classic VS Code uh over here. This is

great. Um I hope everyone is having a great great December. I cannot believe it is the end of December already and I refuse to go on break. And it's because Harold and Tim won't let me to be honest with you because they're like, "Hey,

we're dropping a whole bunch of goodies and we got to try it out everywhere.

Gentlemen, I have to know what is an agent skill. [laughter]

I have no idea." So, so you just everyone you guys just dropped it on us and I was just like, okay, Eleanor um who I've been following for a long time on on Twitter has have been like this

huge um I'll drop her her Twitter in here. Huge believer of agent skills. I

here. Huge believer of agent skills. I

haven't really been following them at all because I'm too busy writing custom instructions and and um uh and and um agent MDs and all this other stuff. So,

what are agent skills and why should people care about them? We'll start with Harold. Yeah, I can take a stab. I think

Harold. Yeah, I can take a stab. I think

yeah, both Elellanar and Simon well our kind of influencer community have been really vocal about them. Uh Simon has some good blogs to figure out like why they work so well for him and Elanor as

well. So I think the excitement is

well. So I think the excitement is there's a ton of agent primitives out there. How do you customize your agents

there. How do you customize your agents and agent skills really came out as a really simple and effective way that that just works for people and it's easy to reason about. It's easy to create and

basically what they are at the basis it's a markdown file in a folder called skill.mmd and it has a description that

skill.mmd and it has a description that tells the agent when to include it and then that means the agent like as it sees like oh like this description cell

tells me I should look at this when I think about front end development it loads up the skill uh but then the magic is so that's that's like one progressive disclosure

aspect of agents um that that they can figure out what they need at the time of running and then load it up. And that's

that's uh agent skills has that kind of baked in as a primitive. Um

but there's more progressive disclosure that you can actually in the folder you can have additional files that then that markdown file can also point to and those could be scripts those could be

just uh documentation u that could be images even and just anything that the agent then can pulls in based on the description for the skill and can go go deeper. So it's very

easy to kind of bundle it up in a very minimal description and then a little bit of expanding into the prompt as it loads the skill.mmd file and then even like oh now you actually have a full

workflow and you can look at all these other files. So that's what agent skills

other files. So that's what agent skills are. Um they they are very close to

are. Um they they are very close to existing primitives we already have but but they they do have this sweet spot of nice distribution through this folder system.

>> Nice. How do you see them Tim?

>> Yeah definitely agree. I think the thing that excites me the most about agent skills is one of the things that kind of Harold was pointing to there, like the fact that it basically enables you to use your context window more

effectively. You know, [clears throat]

effectively. You know, [clears throat] >> I'm I'm sure a lot of people here watching this are very familiar with that idea, but basically what context window is about is effectively like you can only send a certain amount of

information to to the agent and to the model. And after that you have to start

model. And after that you have to start cutting things and truncating things and summarizing things. And up until now

summarizing things. And up until now probably you know if you wanted to teach the agent how to do something the solution you would be likely to reach for would be putting a load of stuff in your custom instructions. But then what

you end up doing is like every single time you do anything in that project then polluting the context window with a load of stuff that's just not relevant for the thing you're trying to do right

now. So whereas with agent skills what I

now. So whereas with agent skills what I can do is kind of create these little packages these little boxes you know of a spe that then gets pulled into the context window when I actually need it.

So I can effectively balance across the two. So for me what I would do is use

two. So for me what I would do is use custom instructions for things that are like basically going to be relevant every single time I use the agent. And

then agent skills are a great fit for things that are a little bit more specialist. you know, like routines or

specialist. you know, like routines or advice or workflows that are going to be useful some of the time but not all of the time.

>> That makes sense. So, what you're saying, Tim, is that my custom instruction that I have here that is

very um you it's kind of built up over the year, if you will. Um it just keeps going. This is this isn't a best

going. This is this isn't a best practice.

[laughter] Yeah, I think until now this has been like how custom instructions have turned out for many of us. And I think there's a bunch of things in here that you probably would want to keep in your custom instructions. So like as you were

custom instructions. So like as you were scrolling there was a section on like coding guidelines. That's probably some

coding guidelines. That's probably some something that I'd be tempted still to keep in custom instructions because it's so like broadly useful for many many like almost every activity you're going

to do with your agent. whereas when it gets to more specialist things, you know, talking I think there was a section on like how you do CSS for example, that thing could be a good fit for a skill because when the agent gets

into the mode of like, hey, now my job is to write some CSS, it can then pull in that that relevant context and you can help to have a better balance of like what things are exposed to the model all the time and what things are

exposed to the model part of the time.

But this isn't exact science. Like we're

all going to be kind of figuring out together and as a community like how we split between these different primitives. And you know, this is very

primitives. And you know, this is very new. So if you if if right now you've

new. So if you if if right now you've got this massive custom instructions file, don't feel bad. I've got that.

Like lots of our projects at GitHub have got that. And we all we can all use the

got that. And we all we can all use the holiday break to like figure out how to pull these things apart and deal with the spaghetti.

>> Totally. Yeah, I think that makes a lot of sense. I think the other thing that

of sense. I think the other thing that was really fascinating, I was building some skills last night was that I had a bunch of information in my custom instructions uh that were that were

about running like CLIs or you know applications on my machine. Like for

example, I have this website visualstudio wallpapers.com. It's a very

visualstudio wallpapers.com. It's a very beautiful website that you can switch between purple and blue uh on here, but I vive coded this out. And you have like all these different desktop wallpapers of all the different things inside of

here for like the 50th uh 50 million user stuff, right? So, you have all these different like VS and VS Code themes in here, which is really cool.

And this is all vioded out. But I have all these super high-res images over here. And I actually had this in my

here. And I actually had this in my custom instructions last night, which was using image magic to do all of my um image resizing, but I was passing that

context every single time I was just making a CSS change. So I put that into a skill, right? Here's how you use image magic. Here's how you do like these

magic. Here's how you do like these PowerShell scripts that I run, right? To

actually do the different resizing and and as I'm building these out, it has to figure it out itself. It has to figure out how I want it to be done and different guidelines in here. And that

sort of like was the thing that you were just saying is this was stuck in my custo this entire 150 lines maybe it's 100 lines of code uh or markdown were stuck inside of my custom instructions.

That's just a shame to waste that context window. So this is an open

context window. So this is an open standard right? This isn't like a

standard right? This isn't like a Microsoft thing. Correct.

Microsoft thing. Correct.

>> Yeah. It's currently so um originally created by anthropic was cloud skills for around uh since October. Like that's

that's what's interesting about the timeline. People were excited about this

timeline. People were excited about this in October and now it's uh December and it's already something that the community adopts at large as something

that we all should kind of do as a as a best practice because we got so excited.

So it's an open standard that defines the very basics of just the files. I

think it's it's early. So I think that's what I want to call out is that there's more questions on like oh maybe there is could be a shared folder for all of these like what is the story for the

script runtime like right now a lot of the anthropic skills won't just work out of the box in any other client because they they're optimized for kind of the VM that cloud.AI runs potentially. So

there's a lot of assumptions people make when they built these skills on where they run and how they run. So there's

probably more either in this bag or related work to kind of make it easier to just created once and share it out um as well. Right.

as well. Right.

>> Very cool. Yeah. And it looks like here there's some front matter. So name

description. I'm assuming the models are using that to understand like what they're calling. Is that correct?

they're calling. Is that correct?

>> Yeah. Yeah. the the basically what what you happen what you have when you have a list of skills that the agent is aware of that means just they're in the system prompt kind of the agent harness

co-pilot or claude gave the agent a list of here's all your skills >> it frames it as basically as soon as you start before you start a task check this list if you need anything like this

specialist knowledge that will make you better please look at it the problem crafting blah blah around it like to really really look at it Um, and then it just the the main information it has is

basically the the description on what is when and how to use it. That's what you should think about when you kind of prompt craft the description. And then

it gets the name and the location of the skill.md. That's kind of the main entry

skill.md. That's kind of the main entry points.

>> Very cool.

>> Yeah. My experience of playing with this so far is that all the normal prompt crafting stuff that we've all got used to continues to be really important. So

you know the description you give in that front matter is going to make a big difference to whether your agent decides to pull in the skill at the time you want to pull it in. And then the tech the instructions you have inside are

also going to have a massive impact. So

when I was kind of playing around with skills I found you know if you just write it as kind of advice then I found the agent would decide you know sometimes I'm going to listen sometimes I'm just going to ignore you. Whereas

writing it clearly as like you must do X like this is the process you have to follow then I saw a lot more success. So

all the stuff you've learned about generally prompting LMS or writing custom instructions is going to work really well here as well. Here's what I did last night is I copied this URL the

specification and I went into into VS Code and I was like hey I opened it this nice and wide and I zoomed in. This is how I code. I

said "Hey I want you to like I want I want you to extract skills into my skills folder and use the

spec, you know, use the specification link basically like go analyze my custom instructions, see if I have skills, and then break them into skills." Basically,

[laughter] that's what I did last night and that was actually pretty helpful because like you said, Tim, I think what I love here, I feel like this this documentation was almost written for models to consume because like good,

poor, like you know what I mean like required, not required, you know, it's like very [laughter] very very nice of exactly what it's going to do and a good example of it which I think is is delightful. We have

our own documentation. I'll put a link there for all the customization. So

people were asking a lot of questions about custom agents and instructions which are kind of like rule files and prompt files and all those things like that as well. There's all that stuff uh which is cool. So you can you can dive

into this uh as well which is great and I love this is like skills versus custom instructions. When would you use it?

instructions. When would you use it?

When wouldn't you use it? You know you can expand this table. That's a quick fact um for you. Very nice uh there. So

all sorts of things and our skills can live in the clawed skills or GitHub skills which is nice. We're going to talk about that as well. Before we get into a demo, also point out awesome co-pilot, which is a great uh GitHub,

and there's now I saw I don't know, did you do this Harold? Was this you, Harold, that did a uh uh skills >> was me? Yes, I did this the day before and then uh the awesome people from

awesome co-pilot helped me get it in quickly. So,

quickly. So, >> very nice. We have a skill web app testing. We'll go through that as well,

testing. We'll go through that as well, but let's just get into it. Uh Harold, I know that you got a sweet, sweet demo.

It's kind of like let's do like a hello world. A lot of people asking like how

world. A lot of people asking like how do you where is it at in VS Code? Can

you enable it in VS Code? And Tim's

going to show the CLI and cloud agent as well. So, I'm super excited about that.

well. So, I'm super excited about that.

But yeah, let's uh you want me to bring up your screen?

>> Yes.

>> Okay. I always like I always like to ask first. Uh oh,

first. Uh oh, >> you need to do that.

>> You're good. Okay, you're good. Please

appear >> there. There you go. My powers. Um yeah,

>> there. There you go. My powers. Um yeah,

so we This is insiders. So that's really important to call out um the the latest and greatest of agent skills. The thing

actually called agent skills is an insiders. If you open VS Code stable,

insiders. If you open VS Code stable, which is the blue icon, then you will still have claw skills. So that's just the the speed of development that's happening here.

Probably going to pull it into stable beginning of January just to make it easier to use. Um so you will see that happening. So basically it's um this use

happening. So basically it's um this use agent skills setting has to be checked and then we going to look into basically. GitHub site skills the

basically. GitHub site skills the co-edited uh folder and new user folder and still look at cloud skills because that's kind of the ecosystem where people have skills right now that's just

a folder and it's the same for the coding agent and CLI as well and we also link you to our helpful docs um that I also wrote up. So yeah, once you have

that enabled basically it falls into the like list of things that the agent already looks at. So the agent already has in this case I have a uh I have a

workshop open that I that you can find on YouTube from from two weeks ago and it was like the basically used all the primitives we have. So we have promps

for like one is just to set up the repo which is a really cool prompt. Um we

have agents >> control can you control plus for me one time >> plus >> command plus there. Oh perfect. Ah I can read it now. Thank you. just just yell

and hands right um okay so we have these these in these these agents these instructions um and then promps and uh anything else and yeah I guess we have

we don't have an instructions file in general that was like part of the workshop create one so you can imagine that one but I have this one which is really cool uh this is actually based on

a blog post by anthropic that they have is front improving front end design through skills and they basically have and you we all ran into this. As soon as

we go into VIP coding mode with cloud, you will get purple gradients if you're not careful. [laughter] So just make me

not careful. [laughter] So just make me a beautiful website is going to be purpley and it's going to have gradients and then you can really see the models design aesthetics through some of these

uh design choices it makes. So this is just copied from this blog. Um and I love this this prompting style of like kind of helpful prompting next morning.

Hey, you tend to converge toward generic like on distribution output and front design. This people call this AI slop.

design. This people call this AI slop.

I'm sorry, but you do this. And so it's it's really cool system. But then now that we have skills, this this could be a skill. This is not something

a skill. This is not something necessarily you need to have an instruction. It doesn't describe your

instruction. It doesn't describe your codebase. It's just like this is how you

codebase. It's just like this is how you make better code in general. It could be used maybe doing code review. is like

when the the code review agent on the GitHub site can see like oh like actually I shouldn't use overused font families and then once I see a design with that like you shouldn't use inter robboto here like maybe pick something

more different but it's not necessary code review it's more of a design review so let's make this a skill so you're going to take this whole thing you already see this has a name descriptions

so and this is what custom instructions and copilot already gave you um so we can do it here we can just uh copy this file and make it we're in GitHub so we

can keep staying here and make a new folder skills and copy this in. Now we got to rename

this to front end design slashskll.md

and we we got the skill.

>> Wow. Skill skill made >> skill made. Yeah, this is now only for GitHub copilot agents. So if you want to have it across all maybe other agents

we're using. We want to maybe put this

we're using. We want to maybe put this into cloud. That's where right now most

into cloud. That's where right now most most look and hopefully in the future there's a one place to put those or I

can put them into my user folder. I also

have um this is actually the way I I work in my user folder for cloud skills.

I just basically have it in VS Code. So

if I just open this one, I have it open here on the side. These are all kind of cloud skills I was trying around playing around. So one is actually a skill

around. So one is actually a skill creator. That's what you did. just point

creator. That's what you did. just point

it to the website to make a skill.

There's a skill to make more skills. So,

but that's one way to manage it as well.

So, but to look at like now now I can actually go in um and ask it which skills do you have? Classic

question. Um it actually have a bunch of ideas what skills it has. It it

understands its tools also as skills and a few other things.

But there's a skills section and I so it now has front end design which is mine and then the other stuff I have from the from the user folder right and the way

now to look behind the scenes a bit this is the chat debug log which you can enable in inst

view right that's the view if I click into it we can kind of look behind the scenes briefly to see skills down here So that's how it looks like in a prompt. It's just here's a

list of skills name description. So as

Tim said, the description really matters to make sure this is used at the right time. And as I said for front-end

time. And as I said for front-end design, it's like use this skill when user asks design like give it context when to use it and what it provides so the agent can figure out how to use it.

Yeah. So that's the basics of like the simple skill. There's no additional

simple skill. There's no additional context here. I could pull in maybe a

context here. I could pull in maybe a design reference guide in a markdown file if it really wants to go deep.

maybe some examples.

Um, but that's that's kind of the basic just skill.md version of this.

just skill.md version of this.

>> That's really cool. I like that you had the sort of user level stuff like, hey, I'm doing this all the time in a bunch of different areas and I want these skills to be available. And previously,

you can even have custom instructions that are doing that as well. But again,

that's a lot of overhead compared to really what I'm understanding from you and Tim is that it's really just understanding that that front matter metadata. So the context is really

metadata. So the context is really shrunk down very small basically.

>> Yeah. Yeah. These these things shouldn't be necessary and then also to make them transferable, right? You can have a

transferable, right? You can have a tailwind for scale. I could move this out now. Um it's mostly about how to

out now. Um it's mostly about how to write it. I think that's that's still

write it. I think that's that's still the discussion we still have to have. Um

like when to use instructions versus skills. I feel like instructions are

skills. I feel like instructions are still more helpful in the way when they purely focus on how to write good code because then they can help you to pull it in for example into code review as

well.

>> So any coding related agent >> if you have a good custom instruction set that has like a domain instructions file and a domain specific instructions file for the repo. you can still

automatically pull those in because I also have these apply to systems in in the in the front matter and say like oh you write wrote tests like let me look at my test instructions and then review

that those uh passcode. You don't want to necessarily have a skill that describes how to basically write write the best tests in that folder. That that should be a

that folder. That that should be a probably custom structure for now. And

then skill can maybe talk about how to think about tests, how to like have a workflow to write good tests. Maybe it's

about test-driven development. Um so

there's still um probably some convergence happening in that in this primitive space to figure out like these are these are the right path right now.

There's definitely if you think about one use case, you can find probably find this a solution for that use case in four different ways.

>> Very cool. Awesome. How do you how does it know how to run the skills? So you

put it into subfolder front end design skill MD like how does it know to actually run those?

>> This is what I showed here the the log for the the prompt. It basically what tells you when the user asks you to perform a task >> use the read file tool. So this what

happens here. Uh, if I go in here and

happens here. Uh, if I go in here and ask it to, for example, redesign the app to

be a cozy coffee shop design.

>> Oh, I like that. That's my jam.

[sighs and gasps] >> So, it gets context. Uh,

it will ignite this left side. Make it

pop.

and it should look at the skill.

>> So, we're assuming here that like just how like we previously like load up a bunch of custom instructions that it would [clears throat] now understand, hey, here are the skills that I have going on and then here are the skills that I'm

going to apply basically like it's not like it's not like a it's it's not like a script that it's running. I wanted to like sometimes I think when I first saw skills I was like, "Oh, it's going to like run this script." Like that's not what it's doing, right? It's not like a

script that it's running. It's a set of uh it could be scripts, it could be information about that, but it's a set of of anything like here's how to do this thing and then incorporate that into your context window. Is that

correct?

>> Yes, it's more it's more in the or at least out of the box, it's more context than scripting. Like in some cases, it

than scripting. Like in some cases, it is very scripting heavy. Um, like the other example I'd like to show that makes a lot of sense is

where's my test skill? This one is maybe easier to understand in a way that so you can just ask it like as soon as you install a skill basically just ask it I edit the skill can you make something

cool with it and that's really like the most basic example like you don't necessarily attach the skill but it's just natural language like there's a skill look at description load it up and

do something with it and that's also the way I like to use MCP server sometimes I just install MP server I I don't want to look at all the tools I just want to ask the LM this is speed over like what can it

because the tools often describe specific workflows and specific like use this tool first and this tool and the agent can figure it out and then have a

much nicer onboarding to the MCP uh compared to what I would I would do. So

in this case we can see basically it loads up the skill on D which is in my folder and that's an interesting example of of a skill description. A it's very

long this it's massive. So it's like a fullon basically how to do algorithmic art workshop in a markdown document.

It's like you're >> you're reading you think about algorithmic philosophy creation uh then you express it with p5 js. So you

wouldn't if you that I that's I think what people have to be careful about like if you just imagine oh this is a cool skill that just describes how to do p5 js it's not that it's a full-on

algorithmic art mindset in a box so you have to be this is what what makes I think skills tricky just like you makes custom agents tricky you have to understand what's behind the prompt and

how it's meant to work but this is like deeply analytical of understanding uh a group philosophy uh the seed the conceptual seed and but

then it it's very practical as well because it has this example viewer file in here as well of just a starter template to go from >> and that's that's why it's so good in the end to create this because it has

like a good starter template.

>> It has this reasoning approach and how to create interesting examples and then because it has files and context and a workflow it just comes up with something really cool.

>> Very cool. I think um Bill here in the chat was saying are you are we to think about it more of like metacognitive recipe like you know kind of like you're saying like here's a recipe on how to do something like you know I think I'm one

of us said the way you think about it right here's the way to think about processing a PDF here's a way of thinking of doing algorithmic art is that kind of like recipe style

I think it's that's where I see many of the example skills also going for anthropic it's more Um, it's more about the LM couldn't do this before, the

agent couldn't create PDFs before, the agent couldn't create powerpoints before, and then the skill basically is like here's a script uh to create these things. If you have this over here, so

things. If you have this over here, so it now loaded up, we're going to run the server.

So this was it create the file. It runs

the HP server from Python to preview it.

And now it's actually going to open the in editor preview to show it to us.

>> Wow, cool.

>> And there we have the [sighs] beautiful bioluminescent depths.

>> Yeah. So kind of like before if you didn't have this skill the model right whether it be opus or GPT or whatever the model is right it would look at its corpus of data or like understand it and

it would try to figure out what it interprets right but what we're doing is sort of guard rails and how to think and how to construct it. But if you're building and you're in this repo, I think the important part is like you're

saying is this application be doing a thousand different things. But if you throw that all into your custom instructions, that's going to be parsed every single time kind of blowing your context window for there where now we're like, hey, we're doing this specific

thing. We're creating this art. So let's

thing. We're creating this art. So let's

deploy this one. We're load up this one thing into the context window and then do it. I think that's what Tim was

do it. I think that's what Tim was saying before. So I think like breaking

saying before. So I think like breaking it down like we've broken custom instructions into like hey here's how I want my C#, here's how I want my CSS, here's how I want this thing, but now this is like here's I want you to think

about CSS in general, but don't do that unless you're actually doing CSS work.

>> Yeah. Yeah. It's it's definitely leaning into something. So what does

into something. So what does capabilities in an agent mean really? Um

and it could be something that the agent usually gets wrong or cannot do at all.

Like if you ask it to make a PDFs, it probably finds 10 different ways to somehow make a PDF and maybe one of them succeeds or all of them fail. But this

is kind of in this case there's a this is the anthropic skills repo on on GitHub and it has basically it has all the scripts that are proven to work with

the right dependency, the right packages already baked in. So it just raises the chance from one out of 10 to 10 out of 10 that it gets it right. Once you ask

it to make a PDF, it's like I have this skill. Let me look it up in my in my

skill. Let me look it up in my in my skill database, my capabilities, and it will will find just the right amount of information, just the right amount of

scripts to do this, right?

>> That's cool. And like you're saying here, there's not just markdown files, there's more code in there, too. Like

you can have script files, for example, like C# script files, Python script files, JavaScript files, and they're kind of like tiny little helper

utilities to to deploy. Tim's shaking

his head. I'm getting it right. If Tim

If Tim's approving, then I feel like I feel smart all of a sudden. Thanks. Am I

getting it right, Tim?

>> You are. [laughter]

>> I like that. Cool. This is awesome.

Yeah, I think that that's that's this is cool to see, too. And I hope awesome co-pilot grows into this and it's cool just to see the cloud skills there.

That's awesome. Awesome. This is Harold.

This is fantastic. Should we hop over to Tim to see it in the CLI and cloud or you got more Harold? Are you good?

>> No, this is all I had. We're all

>> That's cool.

>> That's much much cooler stuff.

>> Well, it's Tim. So only high expectations are high.

Howard Howard set the expectations very high for me here, which is dangerous, but I'm gonna I'm gonna try my best to live up to those high expectations. So,

let me just um share my screen. So, I'm

going to start by showing some stuff in the Copilot CLI. If you haven't already used the Copilot CLI, then definitely give it a try. It's super easy to install. You can just install it by

install. You can just install it by running npm install-g github/copilot and then you're going to get it. Um,

what is the copilot CLI? It's pretty

simple. It's like the agent that you have in VS Code except instead of running an ID, it runs in your terminal.

I wouldn't say that it's like better or worse than what you have in your IDE. I

think it just comes down to like different people like different things and and that's okay. We don't all have to like using the same things and we can have like different different products, different tools for different people and

and how they how they like working. Um,

and the the example I want to show today is kind of maybe a little bit interesting and a bit weird in that I'm going to kind of confess that I don't only use the Copilot CLI for doing

coding. I use it for doing other things

coding. I use it for doing other things as well because it's useful to have an agent that can use my computer and do stuff for other kinds of tasks as well.

So, one of the things that I do relatively frequently because I'm, you know, sharing demos and like sharing kind of examples of my products being used is editing videos and cutting them

up. So I'll do like a screen recording

up. So I'll do like a screen recording that's maybe like five minutes long and then I'll want to take like a specific 20 seconds from it or a specific one minute from it or something like that

and take it into its own file so that I can share it. And if you've ever used ffmpeg which is like a very popular tool for doing these kind of video editing things in the command line you will know

that like the command line arguments are pretty insane and confusing and hard to learn. So whilst I like do this video

learn. So whilst I like do this video editing stuff somewhat frequently, I don't do it often enough to like actually remember how to use it. So

every single time in the old days I went to Google to get advice like on how do I use this tool? Like what are the arguments? So I'd end up on Stack

arguments? So I'd end up on Stack Overflow. But now I use an OM to do it.

Overflow. But now I use an OM to do it.

I I use an agent to help me to do it.

But one of the things that I found often doing that is that the the models both like open AAI models and entropic models make some common mistakes from my perspective in how they

use ffmpeg and they like every single time you use it make the same mistakes that mess up your video. And one example I've got is like I don't actually understand how any of this works but there's a thing in videos called key

frames. And what I find is like when I

frames. And what I find is like when I try to cut a video up, it will have like weird black sections at the beginning and the beginning and the end. And every

single time I ask an agent to do that, it always messes it up in that way, which is very annoying. But I don't necessarily want to put that in my custom instructions because like doing video editing is like 0.1% of the stuff

that I do with my agent and it's just like essentially rubbish in the context window that's not useful most of the time. So this is a great example of how

time. So this is a great example of how I can use a skill to help me to do stuff better. And I'm going to use a slightly

better. And I'm going to use a slightly different example to what we saw with Harold. So Harold showed kind of having

Harold. So Harold showed kind of having skills inside your repository, but with the C-Pilot CLI, and I think this is coming to VS Code as well soon, we also have the ability for you to kind of have

skills that live in your home directory.

So instead of just having it for one repository, you can just have a skill for like for you as a person. So for the copilot CLI, we store them in um copilot

in the home directory and we have a copilot skills and in there I've created a skill called video editing and I can jump into that and you can see it's super super simple. It's just that

skill.md file that we've already been

skill.md file that we've already been talking about. So if I just open that

talking about. So if I just open that up, we can see how that file kind of looks and works. So it has a simple name. It has a description. So here I

name. It has a description. So here I kind of I had this thing where it says invoke this skill whenever you were asked to edit a video because I found when I was using this that if I didn't put something like that it would often

just ignore me and not do what I wanted it to do. Then I've got a bunch of instructions here which are basically explaining like how you deal with this key frame issue like how you do this video cutting in a way that doesn't lead

to weird results. And it has a few other tips in here as well on like how to slow speed up and how to slow down videos.

like I actually unsurprisingly used Copilot to write this skill. So I talked about the things that I wanted to be able to do and the problems that I'd had and asked it to help me to to write a

skill to do that. So that's kind of the setup there. And now I'm going to jump

setup there. And now I'm going to jump into the Copilot CLI to actually see that in action. So I'm going to run Copilot. I like running it with the dash

Copilot. I like running it with the dash banner or because then you get a nice fancy animation when it loads and I I like seeing that especially if I'm doing a demo. And to be honest, I like seeing

a demo. And to be honest, I like seeing it every time. So I I have it there. And

then in the latest version of the CLI, we have a SLS skills list commands. We

can quickly see what skills we have installed. And it will show me personal

installed. And it will show me personal skills that are for my user. And it will also show me like skills in my project.

And now I know that it's there. I can

now actually try to use it. So, I'm

going to say to co-pilot like, can you cut can you take the last 20 seconds from movie.mpp4

from movie.mpp4 and put them in a output.mpp4 file. So,

before I had to like go on Google or Slack overflow whatever to like find out how to do this and then like hack around and try a bunch of things and now copilot can do it for me. So in the CLI

we have this experience where when the skill gets invoked we just show a little thing in the timeline so you can see that the skill has been pulled into context just to kind of give you that

understanding of what's going on. Um

then the first thing it's doing in my prompt I said the last 20 seconds and in order to do that the first thing it has to figure out is like how long actually is this video that you've given me. So

it's going to run a command in order to do that and I'm going to say yes like go ahead and do that. We can see here it figured out it's 40.27 seconds long.

Very precise. I like that it's got six decimal places just to make sure that we're really certain about how long the video is going to be. And then it knows how long it is. And now I can run a command to actually make that edit for

me. And because it has the skill, it

me. And because it has the skill, it isn't going to make that annoying key frames mistake and leave me with like a weird black part at the start of the video. It's going to give me exactly

video. It's going to give me exactly what I wanted. There we go. It's doing

it now. Finish. Done. I extracted it.

So, this is a nice like I think really practical example of of using a skill.

You know, it's not something I'm doing all the time, so it probably doesn't make sense to have it in my custom instructions, but it can pull it in and add that extra context when I want to do this kind of task. And maybe this isn't

relevant to you. Like, you're probably not a weird person like me who like uses the copilot CLI to like do video editing, but there probably are other examples that may be a little bit like this that are useful for you. Well, I

think this is super cool because it kind of gets to the example that I just had, which is like image resizing. Like I'm

building iOS apps all the time and I'm building websites all the time. I need

to resize images. I need to work with SVGs all the time, which are super complex. And I that wallpaper website is

complex. And I that wallpaper website is just that like how often am I adding a wallpaper? Well, not that often, but

wallpaper? Well, not that often, but when I do, I need it to very much understand how I resize and where I put the files and where I do everything.

Like you're saying, you might be working on like a video website, right? And this

might be a core piece of functionality where you are literally putting different brand assets and things all over the place. And now you have this skill this with you all the time no matter where you go.

>> Yeah, >> that's super cool. I like that some of the the nicities there of the CLI. I'm

sure that um Harold and the the VS Code team will steal some of the nicities of what skill was run and when it was parsed and we'll get a slashkills.

Harold, get on that.

Yeah, there's already tons of feedback like one one is for tools, you can nicely select which tools are available during a run. So for skills, you might also eventually reach a point like I have 50 skills installed like I don't

want to and then you're in my user folder because like sometimes I want to extract the video but then suddenly you talk about like some other video piece on your website and then suddenly it always reads the other skill and then as it's all context right and especially in

this one it can be also a large document as I showed with the computational art.

Um, so it's going to be interesting how to um basically make skills behave at scale without constantly readjusting the description to like, oh, it triggered

because I talked about art like I need to just like don't don't use this when I just talk about art or something. So

that's that's going to be still like the control layer for users too. going to be interesting. Also, I think in this demo

interesting. Also, I think in this demo is what is highlighted that I think one question I get like I get many questions about is like the two questions like how is this different than all the other stuff like

instructions and I think we talked about that one but like how's it different than MCP I think that's an interesting one because there is this control layer in

all the agents that you still get script execution you like command execution and script execution and you can confirm it.

So it's a really uh good control layer to understand like what's being executed because of a skill and then still being in charge versus

>> a lot of skills uh run scripts in VMs and other places where you might not even have control about u when it runs how it runs uh what the inputs are but this is think the the some of those

controllers will help to make skills more approachable that you can just try out skills because you're still in charge to hitting yes execute this at at the point in time and which makes them

also more composable than maybe other primitives.

>> That's cool. Now, what I like here so far is that these same exact skills, you could just pick that skill up anywhere, right? In in in VS Code, but also in the

right? In in in VS Code, but also in the cloud agent, correct, Tim? Uh because I don't know if you know, Tim, quick little humble brag. I I'll remove your screen so you can bring up your other

one. Um, the cloud agent team when the

one. Um, the cloud agent team when the mission control was coming out, they did reach out to me and they said, "Hey, James, I see that you're a power user of the cloud agent. Um, we would like for

you to to demo this bubble and like or like uh try out some of the new features." Uh, I'm not going to humble

features." Uh, I'm not going to humble brag that maybe I use the cloud agent all the time, but I have this philosophy is that um before I sign out for the day at work, I assign something to the cloud

agent. Before I go to bed, I assign

agent. Before I go to bed, I assign something from the cloud agent. And when

I wake up in the morning, I assign something to cloud agent and like you know when you're like in the shower and like your best ideas like there in the shower somehow I don't know what it is something about showering just unlocks

magic like ideas. Well, you know, we just have our cell phones. I just open the GitHub mobile app and I always just assign something. So it's like get out

assign something. So it's like get out of a shower, have an idea, assign it.

And uh the cool part yesterday my power was out for five hours here and I joked to Pierce because he's like is everything okay? I'm like, uh, I don't

everything okay? I'm like, uh, I don't know if I've written uh more code in my life when the power has been out for 5 hours because I have 18 ongoing tasks right now in the cloud [laughter] agent

and I'm reviewing them and merging them and then just downloading like new builds of my iOS app. Uh, I'm sitting here and I'm doing an entire new achievement system. I kicked it off

achievement system. I kicked it off before we stream because why waste an hour?

>> Yeah.

>> When I could be coding at the same coding at the same time. So, I'm a big fan of the cloud agent. If anyone knows me, it's my favorite demo on stage is to talk to my phone and then by the end of

the session, I am reviewing that code inside of VS Code, which is amazing. Um,

and Tim, many people do know you from the cloud agent space as well. But, so

can I use these skills there as well?

>> Yeah, you can. Um, and thanks for being an ambassador for the coding agent in the cloud as well. Always always love to have fans out there. Um, it's a super cool tool. I mean, I have to say that

cool tool. I mean, I have to say that given that I work on it, but it's something that I'm using more and more every day. Um, and you know, it's great

every day. Um, and you know, it's great to hear from other people, other people using it as well. So, if you're not familiar, Copilot coding agent is basically an agent that works in the

cloud in the background. So, instead of having to have like VS Code running on your machine or the CLI open, you can start off tasks, then just like shut your laptop, you know, disconnect from

the internet, completely unplug, and that's still going to just keep on running in the background. You can

paralyze many things at the same time.

So in my in my typical workday, I've probably got co-pilot working on two or three things at once most of the time and I can kind of manage that process.

And you know to join VS Code and the CLI, we've added support for that. We've

added support for agent skills here. And

I'm going to show a quick demo of how that works in practice and a nice coding use case that I found for skills. So

this is one of my open source projects.

It's just kind of a simple API built in Typescript and currently it uses Express.js which is a kind of popular but maybe slightly you might say old

school framework for like building APIs.

There's nothing wrong with it but it's not like the most performant or modern option for doing this kind of stuff. So

I was kind of thinking about this and something that I hear a lot from developers wanting to do with agents is like helping them to do migrations and upgrades and things like that. So this

project is not a great example because it's so small. But if you've got a big API, let's say you work at GitHub and you run the GitHub API, you've got thousands, maybe tens of thousands of

APIs. And if you're going to do a

APIs. And if you're going to do a migration to a new tool or a new stack, then that's going to be a lot of work and there's going to be a process you want to follow loads of times. And I

think that's actually a great use case for a skill. So I made a skill called the express to fastify migration skill.

And what this is designed to do is basically teach copilot how to migrate from express which is the framework that I'm using now to a different more

performant one more modern one called fastery. So I have this skill here which

fastery. So I have this skill here which basically explains the process to run through in order to do that upgrade. So

it's quite structured you know it starts with like checking what APIs there are.

Then it has like a benchmark to understand what the performance is before and after so you can actually see the improvements that you're making. And

importantly, it also has a has a step of like making sure that the API doesn't change when you do this migration because that's something you're going to be want to be super careful of if you're doing a migration is like are you actually breaking things or are you

leaving things in the same way that they were before? And I actually did a bunch

were before? And I actually did a bunch of iteration again with Copilot to write this skill because the first time I wrote it, I found that basically it was

kind of it kind of said, "Oh, maybe you might want to do this process this way."

But what I found is like it just ignored it and would like, you know, do step one and then skip straight to step six and it wouldn't do the benchmark and it wouldn't do the like the the checks to make sure that the API hadn't changed.

So I kind of asked Copilot like, "Man, why did you ignore me?" And it came up with this different version of like mandatory workflow. You must pro

mandatory workflow. You must pro complete each phase in order. And this

is the version that we we landed on works. So this is the skill. Let's just

works. So this is the skill. Let's just

see how we trigger it. So to do that, I'm going to use this thing that we have on GitHub now called the agents panel.

And this is just a a a window that we can open anywhere on GitHub to give cloud tasks to the cloud agent. There

are a bunch of other ways you can do this as well. So you can assign an issue to copilot. We've got an integration

to copilot. We've got an integration into VS Code that I've talked about on VS Code Live before and a bunch of other ways as well. It's connected to Slack and GitHub mobile and so many other things. And what we do now is just type

things. And what we do now is just type in our prompt into this box. So I'm

going to say convert or actually I'm going to say migrate the API from express to fastify. I'm going to use claude opus because that's my favorite model at the moment. And then

I'm going to hit start a pull request.

And now that kind of fires off this task that is going to run in the background and copilot's going to go and do its thing. And then once it's done it's

thing. And then once it's done it's going to open a pull request for me and request my review. Now, this is unsurprisingly going to take a little while. So, rather than like trying to

while. So, rather than like trying to use this example, I'm going to go back to one that I did earlier because we don't want to just watch Copilot working for ages and ages. So, if we go through this, we've got a bunch of logs from

Copilot where I asked it to do this task. And very early in the process, we

task. And very early in the process, we have this point where it says activate express to falsify migration skill. So

it quickly identifies that this skill is a good fit for my task and pulls that into the context window and now it's able to actually follow this process that I've told it to follow. So it does

an inventory which is the first step that I give it in the skill. So telling

it like figuring out what APIs there are. It then captures all the responses

are. It then captures all the responses of the APIs that are there now so that it can actually kind of compare them at the end. It runs a benchmark. So we get

the end. It runs a benchmark. So we get um we get some information about the performance of the API before the migration and then it runs through and actually makes the file changes and stuff like that. You know like the agent

you have in the CLI and in VS Code, it's smart. So it like runs your tests and

smart. So it like runs your tests and runs the llinter and things like that to make changes. And then where we really

make changes. And then where we really see the magic in this workflow is that it's actually followed those steps that I set in my skill. So it now at the end actually checks that it hasn't broken

the API and made changes that it didn't mean to change and it runs a benchmark at the end and somewhere further down you can kind of see here. So it notes that it's improved the request per

second by 73% with this migration which is a pretty big improvement from just switching a framework. One of the things that I really liked in here is that when it was doing the benchmarking, it ran into a problem because it found that um

it was hitting rate limits in the API when it was trying to benchmark it, which is kind of funny. So, what does it do? Well, it decides just to remove the

do? Well, it decides just to remove the remove the rate limits for a little while so that it can do the benchmark, which is actually a totally reasonable thing to do to test the performance. So,

this was another funny case. I wanted to like you know show two examples today like one of something not coding related my kind of video editing example and one of this kind of co-pilot working on code

example and if we click view pull request then we can see the pull request that copilot created so wrote me a nice pull request body and then when it was done it requested review from me and

then I can just review this as I would with a pull request created by a human.

>> That's very cool. That's that's awesome.

Uh we did get a good question here uh because I love that we can use them sort of everywhere. Now uh Marshall was

of everywhere. Now uh Marshall was asking does the GitHub skills replace cloud skills when using Copilot? Can you

use either of them? Like will cloud agent CLI look anywhere? Is there

specific like what's the jam there? And

maybe Harold will start with VS Code.

Maybe they all work different. I don't

know. How does VS Code work Harold?

So we we try to align between the CLI and the VS code logic for skills. So we

basically first look into your GitHub skills in the repo. We look into your user co-pilot skills um in from on your

machine and then we look at the claw skills and potentially other places.

We'll see what the ecosystem that's kind of the main place we expect to have users collect their skills right now. So

that's that's kind of the basically the our like one P places we know skills and then we ddup by name in the end. So

that's the the name field is mandatory.

>> So hopefully you have a well scoped name that we can then use to uh to figure out like maybe if you have them in different places maybe you started a new user and

then you moved it into your project and fine-tuned it a bit more. So hopefully

that that order is as expected.

Nice. Tim, what about like CLI and cloud agent stuff?

>> Yeah, same situation. The CLI that works in the same way that that Howard has just described for VS Code. The the

coding agent in the cloud is a little bit different because it doesn't have like a home directory. So, we don't have that part, but it will just load stuff that's in your repository and it supports both the like GitHubskills

path and also the claude skills path.

So, we're trying to be backwards. We're

trying to be like, you know, generally our approach here has been to be very wide on this stuff. And like, you know, why should we only support one place and why should we only support one kind of custom instruction? Like, you know, we

custom instruction? Like, you know, we want to make it really easy to come and use copilot even if you maybe use another tool some of the time. So, wide

compatibility is what we're all about.

>> Yeah, I love that. Makes a lot of sense.

It's pretty easy in code to be like check here or here. U you know, just a little or statement in there. Although,

it does get unruly if there's way too many places to check. Now I don't I know Tim um for custom agents we rolled out like for business and enterprise maybe it's just enterprise like organizational

level agents like so if I have like a I have like a windforms agent I have a C# agent then I have like you know WPF agent that are like because I'm a net developer so I like agents all about like building those types of apps like

especially with cloud agent um is there organizational level skills or instructions for cloud agent? So we for for cloud agent we do have

organizational level instructions but we don't have organizational level skills at the moment. So that is something that we're going to be looking to add in the near future both for organizations and enterprises like feels like a no-brainer

to let people like manage these things at different levels and share stuff across their across their team.

Obviously more dduplication, but it's nice for these ones as as Har said, like they have a have a name and we can use that to dduplicate things. As long as people, you know, use reasonably unique names, then we don't we don't want to

keep sending the same skill to the model 10 times because that's just going to be confusing. But as long as we can kind of

confusing. But as long as we can kind of separate them out and keep them unique, then it will work nicely and we can share stuff all over the place.

>> Very cool. That's awesome. Uh I do love that. Um I'm going to share my screen

that. Um I'm going to share my screen one more time because Harold shared it in the beginning. So if you are using VS Code uh here insiders build you want to update at least to yesterday's or

today's. So I'm going to bring up my

today's. So I'm going to bring up my screen here and Tim I imagine the CLI you just update and cloud agent it just lights up automatically right for this stuff. Yeah for VS Code you

want to go in just type in skills. You

can do it with an S.

Has to be an S, not a Z. I think I think Burke did a Z and like like did not come up. So you type in skills and there's

up. So you type in skills and there's agent.mmds agents.mmd files kind of like

agent.mmds agents.mmd files kind of like instructions but then you'll see use agent skills experimental. So this is kind of what we're talking about. It

looks forgithubskills copilot skills claude skills or claude skills like in in the root name space as well of where they're at. So you can learn more about them there. Um and

they're on the read tool if available as well. So which is cool. Um very very

well. So which is cool. Um very very cool. Um awesome. So if you haven't

cool. Um awesome. So if you haven't enabled it go check it out in insiders.

Harold mentioned it's probably going to drop in to stable in early January. So,

a little uh New Year's celebration, but you I just run we did a survey. I've

been using YouTube surveys a lot. We did

a survey actually uh almost 55% of people watching on YouTube are using either insiders or both. So Rocket

Insiders, it's like you wake up every morning. Not only has the cloud agent

morning. Not only has the cloud agent >> finished a bunch of code for you, but additionally you have a new update to VS Code every single day with goodies inside of there. And then if you're like, "Oh no, something went wrong." You

can just hop over to stable. But I just rock insiders all the time of of VS. >> Yeah, insiders are the people with skills right now.

>> Like the agent skills. Stable has cloud skills.

>> Wow.

>> That's the that naming is just so sweet.

like now we have skill issues that people file. It's

people file. It's so gonna be pretty fun.

>> All right. Well, that on that on that joke, I think we can end the year on a high note with agent skills. Tim Harold,

thank you so much for coming on, showing this all off. I really appreciate it.

It's an honor and a privilege to be on this stream with the two of you.

>> Thank you for having me.

>> Thanks everyone for tuning in this year.

There's so much new goodies. Um, I

believe that Burke and Pierce are recording the final VS Code Insiders podcast in person in the middle of somewhere America. I have no idea it's

somewhere America. I have no idea it's going to happen. So, make sure you go to VS Code podcast.com. Drop a link in the chat over here and subscribe to the VS Code Insiders podcast. You get indepth behind the scenes with the engineering

and PM teams that build the most amazing tools in the entire world. That's going

to do it for this let it cook. So, until

next year, happy [music]