The complete guide to Agent Skills — Transcript

Full transcript

1. 0:00Agent skills are here for Visual Studio
2. 0:02Code. And if you're like me, you hear
3. 0:04that and you think, please, please stop
4. 0:09making me learn new things. Please,
5. 0:12I just want to live my life. The good
6. 0:14news is agent skills are actually pretty
7. 0:16simple to understand and pretty
8. 0:18powerful. So, in this video, we're going
9. 0:20to jump in, take a look at what they
10. 0:22are, how they work. We'll build one
11. 0:24together, and then I'll explain the
12. 0:25difference between skills and prompt
13. 0:27files and instructions and custom
14. 0:28agents.
15. 0:30Let's do it.
16. 0:32So, skills at the most basic description
17. 0:36are just another way to provide
18. 0:37instructions to the model, but they have
19. 0:41some benefits over things like custom
20. 0:43instructions in that they can bundle
21. 0:46together scripts and templates and a
22. 0:48bunch of different files to define a
23. 0:50skill. And this doesn't make a lot of
24. 0:52sense until you see one in action or
25. 0:54build one. So, let's do that. Now, the
26. 0:56first thing we're going to need to do is
27. 0:57we're working in Visual Studio Code, but
28. 0:59we should point out that skills are a
29. 1:02spec from Anthropic, and so they work in
30. 1:05Claude Code and other places, but here
31. 1:08we're all copilot all the time. Skills
32. 1:10are also experimental at the time of
33. 1:11this recording, so there will be some
34. 1:13changes. Uh, but you can see here, you
35. 1:15just need to toggle on skills, and they
36. 1:19won't be on by default. So, if skills
37. 1:20aren't working for you, make sure you
38. 1:22toggle this on. Now, skills, like we
39. 1:25said, are just other instruction files.
40. 1:27That's really all they are. And so, they
41. 1:29just need to be in the right place. You
42. 1:30can put them in GitHub skills, copilot
43. 1:33skills, cloud skills, the cloud skills
44. 1:36at the root of your project. And so, for
45. 1:38us, since we have an empty project here,
46. 1:40let's just start like this and create a
47. 1:42new folder. We'll call it GitHub. And
48. 1:44inside of that, we're going to put a
49. 1:45skills folder. And inside of that, we're
50. 1:47going to create a skill. And we're going
51. 1:48to call it the Hello World skill. Yes.
52. 1:51Yes. doing hello world and then inside
53. 1:55of this hello world folder to define our
54. 1:58skill we're going to create a new file
55. 2:00and we just call it skill.md
56. 2:03just a markdown file here now this file
57. 2:06defines the skill and there are some
58. 2:08things that are required in this file
59. 2:10and that is some metadata at the top
60. 2:12here so you need a name and you need a
61. 2:15description these things are required
62. 2:18for the skill you have to have them so
63. 2:21I've added a name and a description
64. 2:22here. And it's good to be descriptive as
65. 2:24possible with the name and the
66. 2:26description because of the way that
67. 2:28skills are loaded and used, which we'll
68. 2:31look at here in a second, because the
69. 2:33agent should be able to pick these
70. 2:34things up automatically when it needs
71. 2:35them without you having to tell it in
72. 2:37the chat, hey, you need to use this
73. 2:38skill. Now that we have the metadata
74. 2:42here, the next thing you want to do is
75. 2:43start writing the instructions that give
76. 2:46the skill to the model. So, let's just
77. 2:48start like this. We'll just say this is
78. 2:50the hello world skill. Use hello world
79. 2:52skill to respond to the user when oh and
80. 2:56it's fixing my grammar for me. When they
81. 2:58enter the phrase hello world in the chat
82. 3:00and then when they do that we want to uh
83. 3:04respond with and then we can say hello
84. 3:07world. This is my first skill. Yeah,
85. 3:09that would work. Or even better, even
86. 3:12more fun would be respond with um hello
87. 3:15world and asky art.
88. 3:18much more fun. So let's try this here.
89. 3:21Now we have created this skill. How do
90. 3:24we actually use this? Let's open our
91. 3:26chat and then in chat let's just ask the
92. 3:28chat what skills do you have?
93. 3:31And we're going to make sure this is not
94. 3:33attached. It is not attached. So let's
95. 3:36send it. And the model will look and
96. 3:41examine and see if it has any skills
97. 3:43here in the current workspace and then
98. 3:45should report back and tell us exactly
99. 3:46what those skills are. So, I have access
100. 3:48to domain specific skills. Hello world.
101. 3:51A simple skill that responds when you
102. 3:52enter the phrase hello world. And then
103. 3:54it's checking for additional skills,
104. 3:56which we do not have. Thank you, Claude.
105. 3:58You've done enough. Now, how do we
106. 4:00actually use this skill? Well, all we
107. 4:03should really have to do is say hello
108. 4:05world, right? Because the point of
109. 4:07skills is that they get picked up
110. 4:09automatically by the model and it knows
111. 4:12when to use the skill. So you can see
112. 4:14here it says I've read the hello world
113. 4:16skill instructions and we'll respond
114. 4:18appropriately and then we get hello
115. 4:19world in asy art. Not bad. That's some
116. 4:21pretty good ASI art. Now we could have
117. 4:24done this in an instructions file. Yes.
118. 4:28Or a prompt file. Yes. So what's special
119. 4:31about skills? So as we talked about
120. 4:33skills allow you to bundle a bunch of
121. 4:35different files together. So in order to
122. 4:37understand that we kind of need to build
123. 4:39something out here, make this a little
124. 4:41bit more complicated. So in our skill
125. 4:43file here, what I want to do is
126. 4:47uh I want to have a script here. So what
127. 4:51I want to do here is just uh get info
128. 4:54about the user's OS with OS, which is
129. 4:58the node package for doing that. Uh and
130. 5:00I'm going to use Haiku for this. I kind
131. 5:02of like Haiku. I think Haiku gets a bad
132. 5:04rap. It's fast. It's accurate. Perfect.
133. 5:07Okay, so look, platform type, release,
134. 5:09and architecture. I like it. Uh, so
135. 5:12let's go ahead and keep this here. And
136. 5:14then,
137. 5:16so what we could do is say, um, you
138. 5:19know, here's here's the workflow that we
139. 5:21want this thing to follow. Workflow.
140. 5:22Step one, um, run the following scripts
141. 5:28to get system information.
142. 5:31Respond with hello world and ask is step
143. 5:34two. And then step three is uh, provide
144. 5:37the system information obtained from the
145. 5:39script. So now we have kind of a
146. 5:40workflow here. So we should get
147. 5:42something a little bit more interesting
148. 5:43when we do our hello world. So let's try
149. 5:45this again. Hello world.
150. 5:48And now
151. 5:51the skill should walk through our
152. 5:53workflow and different do the different
153. 5:54things that we've defined
154. 5:56namely running the script in the
155. 5:58terminal which you can see it's doing
156. 6:00right here and then returning asky art
157. 6:04for hello world and then returning the
158. 6:06system information as part of the hello
159. 6:07world response. Let's see if we get all
160. 6:09that. And we do. So, here's hello world.
161. 6:11This is exactly what we asked for in the
162. 6:13skill. Now, in this format, this works
163. 6:16just fine because there's just not a lot
164. 6:19to it. But you can imagine if this was a
165. 6:20really long skill, like we're teaching
166. 6:22the AI maybe about how to write API
167. 6:25endpoints for our company, this could
168. 6:27start to get really long. And so, what
169. 6:29skills allow you to do is kind of
170. 6:30modularize. So, we're going to create a
171. 6:31new folder here and call it scripts. And
172. 6:34then inside of it, we're going to add a
173. 6:35new file here called get OS or get
174. 6:39system info.js.
175. 6:42And then we can add this information
176. 6:45here. This whole script can come out and
177. 6:47go into our script here, right? And then
178. 6:52we can reference that. You can reference
179. 6:54this script with relative syntax,
180. 6:58relative path syntax just like you would
181. 6:59reference a normal markdown file. So we
182. 7:01can say run the script like this right
183. 7:06and then where's the script the script
184. 7:08is here in scripts and then get system
185. 7:10info to obtain system information
186. 7:13respond with hello world and askard and
187. 7:15provide this system information obtained
188. 7:17from the script. So now let's run this
189. 7:20again
190. 7:23and we get the exact same thing but this
191. 7:25time it runs the script from the
192. 7:27directory instead of having an inline in
193. 7:29the script file. But let's take this a
194. 7:31step further and let's say that we want
195. 7:33to have a template. So I'm going to
196. 7:35create a new file here and we're just
197. 7:36going to call it template. And you don't
198. 7:39have to capitalize these. This is just a
199. 7:41pattern that you'll see a lot that you
200. 7:43don't have to capitalize. And then uh
201. 7:45here we just have uh a template for a
202. 7:48hello world response in chat with system
203. 7:52info. Let's see what co-pilot gives us
204. 7:55here. Hello. You've triggered the hello
205. 7:56world skill. Oh, look. Ask art's coming
206. 7:59in. I like that.
207. 8:01It knows that we need this. Here's your
208. 8:03system info. System info is here. And
209. 8:06then maybe like feel free to ask. Okay.
210. 8:08Right. So this is every time we hit
211. 8:10hello world, we want the model to
212. 8:12respond with this format and only this
213. 8:16format. Right? And we could do that by
214. 8:19coming into our skill and saying respond
215. 8:21with um respond with
216. 8:26uh the template
217. 8:30and then again we can just use that
218. 8:32relative path syntax right here and then
219. 8:35here we don't need this anymore. Right?
220. 8:39So now we are getting the operating
221. 8:42system info from the script. We're using
222. 8:43the template to define what the response
223. 8:45looks like. Let's give it another shot
224. 8:47here. All right, here we go. Hello
225. 8:49world.
226. 8:51And look at that. We get it back in
227. 8:53exactly the format that we defined.
228. 8:55Hello, you've triggered the hello world
229. 8:56skill. Here's the asky art. Here's your
230. 8:58system information. Please feel free to
231. 9:00ask if you need any further assistance.
232. 9:02Right? The models are really, really
233. 9:03good at following the skill and
234. 9:05following our template, which is exactly
235. 9:07what we've defined right here. So, in a
236. 9:10nutshell, this is what skills look like.
237. 9:14Now you can do a lot of things here like
238. 9:16you could provide your database schema
239. 9:18in a markdown file or some other file
240. 9:20and pass that into the skill. You can
241. 9:21have multiple scripts in your skill. The
242. 9:24possibilities are endless. Now one of
243. 9:27the interesting things about skills is
244. 9:28that they're sort of progressively
245. 9:30loaded so that they don't take up a lot
246. 9:31of room in the context window. And in
247. 9:33order to understand that we need to have
248. 9:35a look at the chat. So let's go to our
249. 9:38chat debug view. And then we want to
250. 9:40come all the way down to the bottom and
251. 9:41let's take a look at our hello world
252. 9:42which starts right right here. Not there
253. 9:45but here you can see hello world. It's
254. 9:47continued here and then it looks like
255. 9:48it's continued down there. So if you
256. 9:50haven't watched my video on prompt files
257. 9:53instructions and custom agents I break
258. 9:55down the system prompt in that video
259. 9:57that that video anyway. You should watch
260. 10:01that. But this is the system prompt. I'm
261. 10:03going to scroll all the way down to the
262. 10:04bottom. at the very bottom. What we'll
263. 10:07see here is
264. 10:10right here
265. 10:17you'll see skills. Here's a list of
266. 10:19skills that contain domain specific
267. 10:20knowledge. And you can see the skill
268. 10:22that we get here. It's hello world. So
269. 10:24it's just the name and the description
270. 10:25and then a path to the file. So when you
271. 10:28pass a request to the model, any skills
272. 10:31you have are passed here, but none of
273. 10:33the other files that we've defined are
274. 10:36passed, nor is the body of the skill.
275. 10:39Only this right here gets passed on that
276. 10:42first agent pass. Now on the second
277. 10:46agent pass, let's go back to our debug
278. 10:48view here.
279. 10:52If you go if we scroll all the way down
280. 10:53to the bottom, we can see that the agent
281. 10:55responds with okay, I need to read the
282. 10:58skill instructions and respond
283. 10:59appropriately and this is the file path
284. 11:01that it needs to read. It wants to read
285. 11:03the skill.md file and it does that.
286. 11:06That's the very next thing it does is it
287. 11:08reads that file. And then if we come
288. 11:11down again, so we're looking at the
289. 11:13system prompt, the whole agent turn. So
290. 11:15it calls it, right? It puts it's now in
291. 11:18the the the prompt here as a tool call.
292. 11:22You can see the response from the
293. 11:24assistant is that it has read and now it
294. 11:26knows that it needs to run this uh
295. 11:29script to get the terminal output which
296. 11:31is the very next thing it does. So it's
297. 11:32progressively loading in these things
298. 11:35that it needs. So these skills are super
299. 11:38efficient. Uh and if we keep coming down
300. 11:40you can see it reads the terminal, it
301. 11:42reads the file. Let's go down to the
302. 11:44bottom of this prompt and see now it
303. 11:47sees this is uh this is the template.
304. 11:49It's now read the template and it knows
305. 11:51how to include this all in the response.
306. 11:53So you can see it's sort of like
307. 11:54progressively loading in these files and
308. 11:56executing them as it needs to. Skills
309. 11:58are very cool. That's how to create a
310. 12:02very basic skill, right? You can do this
311. 12:04right now. You can see they're very
312. 12:05simple. I want to show you a more
313. 12:08complex skill because the very next
314. 12:09question you should be asking is well
315. 12:12when should I use the skill. Let me show
316. 12:15you. So technically speaking there isn't
317. 12:17anything that the agent can't do because
318. 12:22it can run any command in your terminal.
319. 12:24So technically it can do anything but
320. 12:26there are things that it doesn't know
321. 12:27how to do that it will try to figure out
322. 12:29how to do and it may or may not get
323. 12:30those things right. So, for instance,
324. 12:33I've added a PDF file here. And this PDF
325. 12:36file is for the Logitech MX
326. 12:40console, which is pull up here so you
327. 12:43can see it. It's this thing here. Very
328. 12:46handy. Should pick one of those up.
329. 12:48They're very nice. Now, I want to see
330. 12:51what's inside this file. And so, if we
331. 12:53ask the AI to do this, we could just
332. 12:55say, what is in this file here? And if
333. 12:59we send this prompt, let's actually see
334. 13:02what happens. And I'm using Opus 45,
335. 13:04which I consider to be currently the
336. 13:06most capable model for coding here.
337. 13:10So it looks like it's found the file.
338. 13:12It's going to try to read it, but it
339. 13:14can't. So essentially, there is no
340. 13:16support for PDFs here. So what we can do
341. 13:19is use a skill to teach Copilot and
342. 13:23Claude how to read PDFs. Now, how do we
343. 13:26do that? Well, we could build our own
344. 13:28skill or we can use some of the ones
345. 13:30that already exist. So, if you go to the
346. 13:32awesome co-pilot repo here on GitHub,
347. 13:35github.com/github/awesomecopilot,
348. 13:38there are some skills here and this list
349. 13:42is growing. And then the other place is
350. 13:44if you go to anthropic/skills,
351. 13:47github.com/anthropic/skills.
352. 13:50And you can see there's a few more in
353. 13:51here. And we're going to use this PDF
354. 13:53skill here. So, I've cloned that repo to
355. 13:56my local machine. So, I'm going to copy
356. 13:58in the PDF skill
357. 14:01from there. I I cloned the repo and then
358. 14:04I just copied in the PDF skill here. So,
359. 14:06you can see it's right here. And you
360. 14:08should recognize this format now after
361. 14:09this video. So, we have the skill.md
362. 14:11file. Here's the metadata here. And then
363. 14:13you can see it's quite long. Uh there's
364. 14:15a lot of different scripts in here.
365. 14:17There's scripts in here, right? There's
366. 14:18all kinds of PDF support here, not just
367. 14:20reading PDFs, but it teaches the agent
368. 14:24how to work with PDFs. So, now let's go
369. 14:26back and try our prompt again now that
370. 14:29we have this PDF skill and see what the
371. 14:32experience is like now that we've taught
372. 14:34the agent how to work with PDFs.
373. 14:37And you can see it used the scripts and
374. 14:39the skill to use some Python to extract
375. 14:41the PDF contents here. And now it knows
376. 14:44what the PDF is. and we can just pass
377. 14:46PDFs with our prompts. Now, right, we've
378. 14:49taught the agent a new skill with
379. 14:52skills. Now, that's how you build skills
380. 14:55and use them. Let's talk for just a
381. 14:57second about when to use instruction
382. 14:59files versus prompt files versus custom
383. 15:01agents versus skills. So, admittedly,
384. 15:04agents are new and we're sort of still
385. 15:07figuring out where everything fits
386. 15:08together. We've come up with a lot of
387. 15:11different ways of passing instructions
388. 15:12to models and some of this stuff was
389. 15:14invented before skills and skills take
390. 15:17the place of some of those things. But I
391. 15:19think generally speaking, you can think
392. 15:21about it like this. If you have
393. 15:23instructions that you need to pass with
394. 15:24every single prompt to the model, like
395. 15:27general information about the project,
396. 15:29that should be an instructions file. If
397. 15:31you have a short prompt that you find
398. 15:34yourself reusing a lot, that should be a
399. 15:36prompt file. If you want to tweak the
400. 15:39way that the agent behaves, in other
401. 15:42words, you want to define specific
402. 15:44workflows that you want it to follow
403. 15:46every single time, that's a custom
404. 15:49agent. Everything else is probably a
405. 15:54skill. But again, remember that all of
406. 15:57these are just building blocks to help
407. 15:59you build out workflows that work for
408. 16:01you and your team. There isn't really a
409. 16:03right or wrong way to use these things.
410. 16:06They're just different tools that you
411. 16:08have in your toolbox to build out the
412. 16:10optimal workflow. That's the new agent
413. 16:12skills support in Visual Studio Code.
414. 16:15It's available today in VS Code Insiders
415. 16:18and Stable. Make sure that you look for
416. 16:20that experimental setting and turn that
417. 16:21on and you can start using them right
418. 16:24away. Thanks for watching. And as
419. 16:26always,
420. 16:28happy coding.