1
00:00:00,236 --> 00:00:05,951
LLMs are powerful, but once you start using them seriously, your conversations can get
messy.

2
00:00:05,951 --> 00:00:12,136
Your prompts will get longer, your context gets polluted, and you start copy pasting
things over and over.

3
00:00:12,277 --> 00:00:17,722
What if instead of rewriting them every time again, you could package them into something
reusable?

4
00:00:17,722 --> 00:00:25,889
This is where skills come in, a lightweight approach to turn repeatable workflows into a
modular and reusable component inside your agent.

5
00:00:25,889 --> 00:00:26,972
Let's have a look.

6
00:00:35,228 --> 00:00:39,009
Hi everyone, welcome to technology explorations at Dataminded.

7
00:00:39,090 --> 00:00:43,211
In this series, we give you an initial look into new or interesting technologies.

8
00:00:43,211 --> 00:00:52,926
My name is Jonny, knowledge teacher at Dataminded, and today we'll have a look at skills,
something that you can use to let your AI agent be more efficient and more reusable.

9
00:00:53,066 --> 00:00:56,067
For this topic, I've invited one of our experts, Jesus.

10
00:00:56,067 --> 00:00:57,141
Welcome, Jesus.

11
00:00:57,141 --> 00:00:57,902
are you doing today?

12
00:00:57,902 --> 00:00:58,409
All good?

13
00:00:58,409 --> 00:00:59,601
All good, all good.

14
00:00:59,601 --> 00:01:02,755
Before we get started, maybe a quick introduction about yourself.

15
00:01:02,755 --> 00:01:06,712
What's your role and how are you working with AI day to day?

16
00:01:06,712 --> 00:01:07,212
Yes.

17
00:01:07,212 --> 00:01:08,703
So I am Jesus.

18
00:01:08,703 --> 00:01:16,259
I've been in Dataminded for over a year and a half and I am working a lot to creating AI
use cases, let's say.

19
00:01:16,259 --> 00:01:24,055
But at the same time, I've loved to use, yeah, every new shiny AI tool to improve my, my
workflow for better or worse.

20
00:01:24,055 --> 00:01:25,556
That's what I've been doing.

21
00:01:25,556 --> 00:01:26,178
Okay.

22
00:01:26,178 --> 00:01:28,968
And so today you're going to show us how to build skills.

23
00:01:28,968 --> 00:01:30,359
Yes, great.

24
00:01:30,359 --> 00:01:37,757
So we are going to use Claude because they are the ones that created the skill spec, even
though now it's open source.

25
00:01:37,757 --> 00:01:39,788
But in my day to day, I use Claude code.

26
00:01:39,788 --> 00:01:46,454
I feel that is the most advanced software at the moment for this, but it might change
quickly in the future.

27
00:01:46,454 --> 00:01:53,439
And I have created a couple of skills, really, really small skills.

28
00:01:53,439 --> 00:01:55,201
One that is to explain code.

29
00:01:55,201 --> 00:01:56,763
So every time that you open it,

30
00:01:56,763 --> 00:02:01,796
You say, explain me this particular code and it's going to do a few things to look at what
you want from the repo.

31
00:02:01,796 --> 00:02:04,527
And then it's going to give you a nice report so you understand it better.

32
00:02:04,527 --> 00:02:09,819
And then I have another one that is quite handy for engineers, which is to explain a PR.

33
00:02:09,819 --> 00:02:15,615
So for example, in mind that you open a branch, you make a few changes and then you want
to craft a pull request.

34
00:02:15,615 --> 00:02:19,797
And then you can use this skill to make this process faster for you.

35
00:02:19,797 --> 00:02:20,598
And then you can.

36
00:02:20,598 --> 00:02:26,573
manually check whether the description makes sense or not, but you don't have to type
everything

37
00:02:36,697 --> 00:02:26,983
It is to re

38
00:02:26,983 --> 00:02:30,622
gives you a review of your pull request before you get the human review.

39
00:02:30,622 --> 00:02:31,163
Indeed.

40
00:02:31,163 --> 00:02:42,277
So what I want to do is first show, it's going to be a bit meta, but I want to use explain
code skill to explain review skill to see what we get as an output.

41
00:02:42,277 --> 00:02:48,594
So because I have installed the skills in my repository, when I put slash, I have a bunch
of skills.

42
00:02:48,594 --> 00:02:51,476
And here you see in the autocomplete this explain code.

43
00:02:51,476 --> 00:02:54,449
So this is the one that I will put in the repo.

44
00:02:54,449 --> 00:03:03,109
So then I toggle and I say, OK, hi, I want you to explain to me the PR review skill in
this repo.

45
00:03:03,109 --> 00:03:04,496
So now it notes.

46
00:03:04,496 --> 00:03:08,748
contains already the code for a skill and now you're asking it to explain it.

47
00:03:08,748 --> 00:03:11,770
Yes, so you see, like, ah will start by finding the code.

48
00:03:11,770 --> 00:03:14,442
Of course, you cannot review something that you don't see.

49
00:03:14,442 --> 00:03:15,854
So it's going to find the code.

50
00:03:15,854 --> 00:03:20,527
Also, quite interesting, because it's Claude I didn't have to even point to the proper
folder.

51
00:03:20,527 --> 00:03:27,795
Like, based on this abstract description or not super fine-grained description, it's going
to find the skill.

52
00:03:27,795 --> 00:03:31,870
Once that it finds, it's going to try to understand the code in a way that is

53
00:03:31,870 --> 00:03:34,352
high level, it throws the explanation.

54
00:03:34,352 --> 00:03:41,135
And because the way that the explain code has been created, it gives it in a way that is
quite educational.

55
00:03:41,135 --> 00:03:44,148
Let's say that you have drawings and you see an analogy.

56
00:03:44,148 --> 00:03:48,521
So the PR review skill is a trained code inspector

57
00:03:48,521 --> 00:03:52,412
Here is how the skill looks like, which is a visual description.

58
00:03:52,412 --> 00:03:53,512
And then this is quite nice.

59
00:03:53,512 --> 00:03:54,772
It's like the workflows.

60
00:03:54,772 --> 00:03:57,343
You type review PR and the number of your PR.

61
00:03:57,343 --> 00:03:58,694
And this is what happens.

62
00:03:58,694 --> 00:04:04,165
We are going to use a subagent that is going to check the divs of your current branch.

63
00:04:04,165 --> 00:04:07,876
It's going to read the files, and then it's going to give you a review.

64
00:04:07,876 --> 00:04:14,567
And then you see here that it's going to trace exactly one by one what's going on when you
run this.

65
00:04:14,567 --> 00:04:25,023
Finally, but this is more of an advanced topic, there is an argument that we put for the
skill that says that you can only trigger the PR review skill when you call it yourself.

66
00:04:25,023 --> 00:04:34,007
Because for example, if you are talking in a conversation and then you say, hey, I want to
review this and that, Claude might think, I need to trigger this skill, but it's not

67
00:04:34,007 --> 00:04:34,567
needed.

68
00:04:34,567 --> 00:04:36,498
You only trigger it yourself when you want to.

69
00:04:36,498 --> 00:04:39,540
And that's metadata that you can change.

70
00:04:39,599 --> 00:04:41,072
So it's basically who is in control.

71
00:04:41,072 --> 00:04:51,661
Either the human can call it directly with the slash command as you showed or the agent
can decide to invoke the skill itself without having an explicit mention of the user.

72
00:04:51,661 --> 00:04:57,401
And in this case, because we want to avoid false positives, we only allow the human to
call it.

73
00:04:57,813 --> 00:04:59,813
For example, the explain code is not the same.

74
00:04:59,813 --> 00:05:01,364
The explain code can be called.

75
00:05:01,364 --> 00:05:08,121
Every time you say, hey, I don't understand fully this part of the code, it should trigger
this particular skill for you.

76
00:05:08,121 --> 00:05:08,682
okay.

77
00:05:08,682 --> 00:05:12,148
So as a skill designer, you're a bit in control of how it gets called.

78
00:05:12,148 --> 00:05:16,714
I also see other more advanced things, like fork agents and allow tools.

79
00:05:16,714 --> 00:05:19,619
These are more advanced topics to design your skill around.

80
00:05:19,619 --> 00:05:24,034
Yeah, basically, this is bit more difficult topic.

81
00:05:24,034 --> 00:05:27,808
But the idea is that we don't want to pollute the main conversation.

82
00:05:27,808 --> 00:05:35,608
So what we do in this skill is that we're going to spin up a fresh sub agent with fresh
context, different tools that is just going to do the PR review.

83
00:05:35,608 --> 00:05:39,512
When the review is done, then it's going to feed back the information to the main agent.

84
00:05:39,512 --> 00:05:42,847
So then you can read only the summary of the review and not the whole.

85
00:05:42,847 --> 00:05:47,382
but also finding the files and doing the diffs and these things.

86
00:05:47,382 --> 00:05:49,077
You don't need to care about that.

87
00:05:49,077 --> 00:05:50,048
Yeah, okay.

88
00:05:50,048 --> 00:05:55,060
And so this is a really nice demo that your skill is already working to show what another
skill does.

89
00:05:55,060 --> 00:05:57,966
maybe you can explain a bit like what is a skill now?

90
00:05:58,341 --> 00:06:05,508
I think that skills are really important because nowadays we have moved from plain LLMs,
let's say models that are like chatbots.

91
00:06:05,508 --> 00:06:08,311
You have a question and they give you an answer to agents.

92
00:06:08,311 --> 00:06:13,366
And agents is a hype word lately, but just means that you have an LLM that works in a
loop.

93
00:06:13,366 --> 00:06:18,782
You know, like you have uh a function that you want to optimize, for example, give you the
best answer.

94
00:06:18,782 --> 00:06:22,606
And then you're going to try to loop for a while to give the best answer.

95
00:06:22,606 --> 00:06:23,326
That's really nice.

96
00:06:23,326 --> 00:06:29,683
But the problem is that the more loops that you do, the more chances that you are going to
pollute the context window of the LLM.

97
00:06:29,683 --> 00:06:32,577
Like you're going to put too many details that are not important.

98
00:06:32,577 --> 00:06:35,950
So the LLM is going to get lost, let's say, like humans.

99
00:06:35,950 --> 00:06:38,883
If I give you too many details, you're going to get lost.

100
00:06:38,883 --> 00:06:40,214
So then because of

101
00:06:40,397 --> 00:06:44,224
basically what we then see when an LLM is thinking in the UI?

102
00:06:44,224 --> 00:06:48,024
It's basically going in a loop and keeps generating output.

103
00:06:48,024 --> 00:06:48,594
exactly.

104
00:06:48,594 --> 00:06:51,507
So LLMs, have been trained now in a way to reason.

105
00:06:51,507 --> 00:06:54,790
So they go step by step thinking about the problem, that's the thinking.

106
00:06:54,790 --> 00:06:55,812
And then they act.

107
00:06:55,812 --> 00:06:58,934
Then they say, now I need to find the files, for example.

108
00:06:58,934 --> 00:06:59,965
I need to read the files.

109
00:06:59,965 --> 00:07:04,031
So then that's what you're going to see, which is the LLM interacting with the
environment.

110
00:07:04,031 --> 00:07:10,729
And is this a consequence of what was previously the chain of thought principle, where you
basically say you have to do everything step by step?

111
00:07:10,729 --> 00:07:11,179
Indeed.

112
00:07:11,179 --> 00:07:17,727
So basically what they have done, which is quite smart, is that they have, let's say,
baked this concept into the LLMs.

113
00:07:17,727 --> 00:07:25,628
The providers, have fine-tuned the models to actually mimic that chain of thought out of
the box.

114
00:07:25,628 --> 00:07:25,966
Okay.

115
00:07:25,966 --> 00:07:31,473
So because of that, that is super powerful because now you can do really complicated
stuff.

116
00:07:31,473 --> 00:07:34,456
However, you can pollute the context window.

117
00:07:34,456 --> 00:07:38,860
Basically you have an amount of information that fits in the memory of your agent.

118
00:07:38,860 --> 00:07:40,442
say it's quite ample.

119
00:07:40,442 --> 00:07:45,197
have like 250 K tokens in our models, which is you can feed books there.

120
00:07:45,197 --> 00:07:52,534
However, a few studies have shown that the more that you put the more chances that the LLM
is going to do something random, like hallucinate.

121
00:07:52,534 --> 00:07:53,665
or lose track.

122
00:07:53,665 --> 00:08:04,239
So that's why we have moved from this idea of prompt engineering, that was the idea of
better prompting the llm, better putting instructions to context engineering, which

123
00:08:04,239 --> 00:08:09,302
basically is the art of putting in this context window only the things that are needed.

124
00:08:09,302 --> 00:08:13,484
You know, the instructions that are needed, the files that are needed, the tools that are
needed.

125
00:08:13,484 --> 00:08:15,115
And then you have a lot of kind of tools.

126
00:08:15,115 --> 00:08:19,777
You have RAGs, MCPs, and then you have the latest, which is skills.

127
00:08:19,777 --> 00:08:30,890
skills are really powerful because basically for me, I feel them as I feel that they are
these kind of really nice way to make this context engineering efficient, in a way that is

128
00:08:30,890 --> 00:08:33,303
efficient, modular are reusable.

129
00:08:33,303 --> 00:08:34,775
It's something that is local.

130
00:08:34,775 --> 00:08:39,761
For example, you have MCPs, or RAGs, MCPs you need to call something remotely.

131
00:08:39,761 --> 00:08:41,593
So it's not in your control.

132
00:08:41,593 --> 00:08:43,615
And RAG is something that is quite technical.

133
00:08:43,615 --> 00:08:46,177
You need to implement a vector database and a few things.

134
00:08:46,177 --> 00:08:56,664
However, skills is just markdown files, metadata, a good structure, and then Anthropic or
Claude is going to handle the rest for you in the background, let's say.

135
00:08:56,664 --> 00:09:06,155
So basically the way I understand it is if you have a reusable process that you can
explain as text, all the steps and the way you do things, you can put that in a markdown

136
00:09:06,155 --> 00:09:09,746
file and the agent will pick it up whenever it needs it.

137
00:09:09,746 --> 00:09:10,506
Exactly.

138
00:09:10,506 --> 00:09:18,337
And also it's not even the prompt, but also you can add Python scripts, for example, or
you can do CLI commands or you can do whatever.

139
00:09:18,337 --> 00:09:24,588
It's just, are the instructions and then the agent is going to be able to execute whatever
you put.

140
00:09:24,588 --> 00:09:35,399
For example, in the PR review, if we go to the definition of the skill, you're going to
see that we are going to ask the agent to run a few commands in the CLI to get what have

141
00:09:35,399 --> 00:09:36,490
been the latest commits.

142
00:09:36,490 --> 00:09:42,715
And is that then also the difference between the previous "commands" where you basically
just inject the prompts in your context window?

143
00:09:42,715 --> 00:09:46,124
Now you equip it also with the ability to run some things locally.

144
00:09:46,124 --> 00:09:46,674
Exactly.

145
00:09:46,674 --> 00:09:50,859
The "command" is more reusable prompt, let's say, which is super useful.

146
00:09:50,859 --> 00:09:55,104
But then skills is a reusable, let's say, function for the agent.

147
00:09:55,104 --> 00:09:56,054
That's how I see it.

148
00:09:56,054 --> 00:09:57,755
It's like a reusable function.

149
00:09:57,755 --> 00:10:01,269
And then it's defined by a markdown and extra components.

150
00:10:01,269 --> 00:10:01,639
Um,

151
00:10:01,639 --> 00:10:09,377
I also recall, the discovery of these skills is also a bit more lightweight because the
agent only pulls them in when needed.

152
00:10:09,377 --> 00:10:11,610
And it's based on the metadata.

153
00:10:11,610 --> 00:10:14,502
So I have an actual example of how that looks.

154
00:10:14,502 --> 00:10:18,844
They use this thing that is progressive disclosure, which is quite powerful.

155
00:10:18,844 --> 00:10:22,386
So in the beginning of your context window, you have the system prompt.

156
00:10:22,386 --> 00:10:27,267
This is something that you don't control And then you have loaded a bunch of skills, for
example.

157
00:10:27,268 --> 00:10:32,020
Imagine that you have a skill that you have written that is used to read PDFs.

158
00:10:32,020 --> 00:10:33,260
The only thing that you keep

159
00:10:33,260 --> 00:10:34,441
There is a metadata.

160
00:10:34,441 --> 00:10:38,254
You only keep the name of the skill and when to use it, when to call it.

161
00:10:38,254 --> 00:10:41,263
That's the only thing that you need to track at this time.

162
00:10:41,263 --> 00:10:44,876
Then the message says, hey, I want to fill out this PDF.

163
00:10:44,876 --> 00:10:49,300
So then the agent is going to be, the PDF skills is going to be a useful thing to use.

164
00:10:49,300 --> 00:10:51,541
So you trigger the PDF skill.

165
00:10:51,541 --> 00:10:54,664
You see that it's now reading the definition of the skill.

166
00:10:54,664 --> 00:10:56,166
Hey, this is the definition.

167
00:10:56,166 --> 00:11:02,547
Now, because in the definition says, if this is triggered, you have to use this Python
script to read the PDF.

168
00:11:02,547 --> 00:11:03,960
And that is what is triggered, you see.

169
00:11:03,960 --> 00:11:06,595
And that's what is done in that part.

170
00:11:06,595 --> 00:11:11,618
Yeah, so basically every time it needs more information, it knows how this information is
there.

171
00:11:11,618 --> 00:11:18,933
So it's kind of an index and it fetches new information by running fetch commands or maybe
even Python commands to execute things.

172
00:11:18,933 --> 00:11:19,544
Indeed.

173
00:11:19,544 --> 00:11:21,606
So this is really good because it's super efficient.

174
00:11:21,606 --> 00:11:23,258
It also lives in your computer.

175
00:11:23,258 --> 00:11:24,935
You have full control of these.

176
00:11:24,935 --> 00:11:34,105
You don't have to go through the internet, MCPs, authentication, you know, like this was
the problem with MCPs that they might be super powerful, but you need to under a lot of

177
00:11:34,105 --> 00:11:39,982
boilerplate that if you are doing things locally, like I need to read a PDF, you don't
need to do all of these hassle.

178
00:11:39,982 --> 00:11:40,698
Indeed, indeed.

179
00:11:40,698 --> 00:11:41,220
Okay.

180
00:11:41,023 --> 00:11:43,759
And so how do I build such a skill myself?

181
00:11:43,759 --> 00:11:46,975
Is it a technical thing or is it something anybody can do?

182
00:11:46,975 --> 00:11:47,967
Not at all.

183
00:11:47,967 --> 00:11:53,209
would say that it's simple.

184
00:11:53,209 --> 00:11:55,150
so this is the repo.

185
00:12:00,916 --> 00:11:56,316
So we have this folder.

186
00:11:56,316 --> 00:11:59,080
This is the definition of what we have.

187
00:11:59,080 --> 00:12:06,258
As I said, we have two skills, the one that is explaining code and the one that is review
codes.

188
00:12:06,258 --> 00:12:07,659
The first one is the easiest.

189
00:12:07,659 --> 00:12:09,552
So every skill needs.

190
00:12:09,552 --> 00:12:11,704
This skill.md, that's the basic.

191
00:12:11,704 --> 00:12:13,336
That's the minimum thing that you need.

192
00:12:13,336 --> 00:12:14,988
And here you're going to have two things.

193
00:12:14,988 --> 00:12:16,700
You're going to have metadata.

194
00:12:16,700 --> 00:12:19,873
You see the name explain code and the description.

195
00:12:19,873 --> 00:12:21,106
This is what it does.

196
00:12:21,106 --> 00:12:26,274
So then the agent knows that they can use this skill when you ask about the code.

197
00:12:26,274 --> 00:12:28,536
That is what is always there with the agent.

198
00:12:28,536 --> 00:12:29,276
That's it.

199
00:12:29,276 --> 00:12:29,602
That's

200
00:12:29,602 --> 00:12:34,142
that's basically what the agent always knows about and it knows how about the rest of this
file.

201
00:12:34,142 --> 00:12:35,896
It's kept there on my disk.

202
00:12:35,896 --> 00:12:36,357
Indeed.

203
00:12:36,357 --> 00:12:42,761
Then for example, this, to be fair, you could argue that it's kind of a command, but
because it's prompts, let's say.

204
00:12:42,761 --> 00:12:45,993
it's like, when explaining codes, start with an analogy.

205
00:12:45,993 --> 00:12:51,966
You see what I draw a diagram, walk through the codes, and call out a uh common mistake,
for example.

206
00:12:51,966 --> 00:12:57,248
if I would be working with a junior engineer, and I want them to be able to catch up and
learn.

207
00:12:57,248 --> 00:12:59,680
This would be a good way to understand.

208
00:12:59,680 --> 00:13:03,234
So this is the bare minimum that you can do with a skill.

209
00:13:03,234 --> 00:13:05,148
But then you can get more advanced.

210
00:13:05,148 --> 00:13:08,230
For example, in this one, we have a few more interesting things.

211
00:13:08,230 --> 00:13:10,173
This is the one that we use to review a PR.

212
00:13:10,173 --> 00:13:13,736
So you see that now the front matter is going to be more complicated.

213
00:13:13,736 --> 00:13:14,367
Why?

214
00:13:14,367 --> 00:13:16,009
Because we have a couple of things.

215
00:13:16,009 --> 00:13:18,230
The first one, again, name, description.

216
00:13:18,230 --> 00:13:18,982
That's it.

217
00:13:18,982 --> 00:13:22,075
We now also get uh an input.

218
00:13:22,075 --> 00:13:25,939
So we are going to get an input into the skill, which is the number of the PR.

219
00:13:25,939 --> 00:13:29,053
So then you are going to fetch only things for that particular PR.

220
00:13:29,053 --> 00:13:34,079
We are going to do this disabled model invocation, which means that only the human can use
it.

221
00:13:34,079 --> 00:13:35,501
And this is more interesting.

222
00:13:35,501 --> 00:13:43,630
So we are going to use context fork, meaning that we are not going to run it in the main
conversation, but we are going to spin up a new fresh subagent.

223
00:13:43,630 --> 00:13:51,845
We are going to use an Explorer agent that is an agent out of the box from Claude that
basically is on to search information, do greps and these kind of things.

224
00:13:51,845 --> 00:13:59,541
And finally, and more importantly, because we know what should happen, we can also limit
the amount of tools that this agent is going to have.

225
00:13:59,541 --> 00:14:09,384
Instead of, hey, have everything that you can have, no, you can only do reads, greps, and
globs, and also use the GitHub CLI to get information about that PR.

226
00:14:09,384 --> 00:14:14,536
And then the description is a bit more complicated, but it's basically review the pull
request from these arguments.

227
00:14:14,536 --> 00:14:15,627
That is the input.

228
00:14:15,627 --> 00:14:21,079
The context you need to do these commands, like the commands to get the context from the
PR.

229
00:14:21,079 --> 00:14:23,870
So as I was saying, the subagent is going to be able to do this for you.

230
00:14:23,870 --> 00:14:28,113
And then these are more checklists in these, like how should you do the review?

231
00:14:28,113 --> 00:14:29,013
What to look for?

232
00:14:29,013 --> 00:14:31,076
And the person defining the...

233
00:14:31,076 --> 00:14:35,929
The skill is the one that is in control to say, this is what I want the skill to do.

234
00:14:35,929 --> 00:14:37,760
This is what I want the skill to look in the code.

235
00:14:37,760 --> 00:14:41,910
Because for example, for me, I work a lot in using infrastructure as code.

236
00:14:41,910 --> 00:14:51,710
So maybe there are some gotchas that I would always like to look for when I'm doing a PR
with infrastructure as So then I put it there.

237
00:14:51,710 --> 00:14:56,253
So I put more fine-tune definitions.

238
00:14:56,253 --> 00:14:57,483
And then the outputs.

239
00:14:57,483 --> 00:15:02,515
Hey, I want you that every time that you give me the review, this is the way that I want
to have the review.

240
00:15:02,515 --> 00:15:03,986
So we have consistency.

241
00:15:03,986 --> 00:15:07,959
And this can be as complicated as possible because you can use scripts.

242
00:15:07,959 --> 00:15:12,430
For example, you can say, I run this script every time that you run the PR.

243
00:15:12,430 --> 00:15:15,381
Or you can have examples of good PR reviews.

244
00:15:15,381 --> 00:15:18,524
And these are things that you would add on top of this folder.

245
00:15:18,524 --> 00:15:20,735
So you would not use the same skill.md.

246
00:15:20,886 --> 00:15:24,971
but you would create new files and reference them in this skill.md.

247
00:15:25,044 --> 00:15:29,489
Yeah, because I heard you need to keep your files lower than 500 lines.

248
00:15:29,489 --> 00:15:37,325
So if you have examples or so, you put them in a subfolder and here you put like a little
local link dot slash and then the file name.

249
00:15:37,486 --> 00:15:38,906
Indeed, exactly as Markdown.

250
00:15:38,906 --> 00:15:39,586
And that's it.

251
00:15:39,586 --> 00:15:42,608
That it's like, if you need to do this, go to that file.

252
00:15:42,608 --> 00:15:43,138
That's it.

253
00:15:43,138 --> 00:15:46,330
And the models are getting smarter by the day.

254
00:15:46,330 --> 00:15:47,852
So that's all that you need to say.

255
00:15:47,852 --> 00:15:50,133
They will say, OK, I need to read this.

256
00:15:50,133 --> 00:15:50,913
And that's it.

257
00:15:50,913 --> 00:15:53,844
And they can get as fancy as possible.

258
00:15:53,844 --> 00:16:00,788
But I have a couple of references on how Anthropic, the one that created this spec, what
are the advice to do?

259
00:16:00,788 --> 00:16:04,279
good skills, what are the best practices, should you look for, for example?

260
00:16:04,279 --> 00:16:05,991
Yeah, cause this is a minimal example.

261
00:16:05,991 --> 00:16:15,118
And so basically you showed that you have this front matter that controls how the skill is
picked up and how it is actually initiated, like the sub agent component and also the

262
00:16:15,118 --> 00:16:16,719
permissions on your local drive.

263
00:16:16,719 --> 00:16:18,661
it can execute these commands.

264
00:16:18,661 --> 00:16:20,162
These are not possible.

265
00:16:20,162 --> 00:16:25,547
then in the body, you basically say, this is how the job to be done needs to be executed.

266
00:16:25,547 --> 00:16:26,919
You say, these are the steps.

267
00:16:26,919 --> 00:16:29,592
These are the commands that you should actually call.

268
00:16:29,592 --> 00:16:34,688
And this gives the agent then a way to do everything, but it's not like the mandatory way.

269
00:16:34,688 --> 00:16:36,538
It can still hallucinate, right?

270
00:16:36,538 --> 00:16:37,269
Yeah, indeed.

271
00:16:37,269 --> 00:16:38,390
Yeah, that's true.

272
00:16:38,390 --> 00:16:39,712
models can hallucinate.

273
00:16:39,712 --> 00:16:43,024
the people developing these models now have this in mind.

274
00:16:43,024 --> 00:16:49,598
They are putting a lot of effort into not allowing the models to hallucinate, but it's,
you know, it's not that exact science.

275
00:16:49,598 --> 00:16:51,299
These are non-deterministic models.

276
00:16:51,299 --> 00:16:59,434
My advice in that sense is that the more instructions that you put, the more brittle that
the logic is, the more chances that the model is going to hallucinate.

277
00:16:59,434 --> 00:17:01,666
So that's why you have these reusable skills.

278
00:17:01,666 --> 00:17:02,666
it's like a function.

279
00:17:02,666 --> 00:17:07,279
know, only keep what is necessary and be as short and clear as possible.

280
00:17:07,279 --> 00:17:09,192
Yeah, okay.

281
00:17:09,192 --> 00:17:10,735
You mentioned a few specs.

282
00:17:10,735 --> 00:17:13,731
Could you point us to the specs that people can use?

283
00:17:13,731 --> 00:17:14,252
Yes.

284
00:17:14,252 --> 00:17:16,758
the ones that creating skills Anthropic.

285
00:17:18,618 --> 00:17:23,561
they have released these skills, authoring best practices, which is a really, really long,
but really informative page.

286
00:17:23,561 --> 00:17:32,162
So they start with, you see, concise is key, you know, this kind of things like why the
example of the PDF, you know, and they give you a good example, a bad example.

287
00:17:32,162 --> 00:17:34,713
the bad example is longer, but also is more brittle.

288
00:17:34,713 --> 00:17:38,766
The concise assumes that Claude knows what a PDF is and how to read them.

289
00:17:38,766 --> 00:17:43,468
You don't need to give stupid details like, hey, use this to extract the PDF.

290
00:17:43,468 --> 00:17:43,908
That's it.

291
00:17:43,908 --> 00:17:45,540
You don't need to tell your life.

292
00:17:45,540 --> 00:17:48,472
Here, for example, this is explaining what a PDF is.

293
00:17:48,472 --> 00:17:51,643
So this for the agent is like, I don't need to know this at this moment.

294
00:17:51,643 --> 00:17:53,504
I just need to know how to read it.

295
00:17:53,504 --> 00:17:54,005
That's it.

296
00:17:54,005 --> 00:17:55,785
um

297
00:17:55,851 --> 00:18:00,004
And then they have more the metadata and then they have more complicated.

298
00:18:00,004 --> 00:18:03,457
More fancier, know, this kind of progressive disclosure.

299
00:18:03,457 --> 00:18:12,204
So you see that in the main skill, the references to all the other markdown files that
then the agent will read if they are necessary.

300
00:18:12,204 --> 00:18:14,109
So you don't pollute the context.

301
00:18:14,109 --> 00:18:14,616
And then

302
00:18:14,616 --> 00:18:19,333
need that front matter, it seems like the front matter is only relevant to your entry
point of the skill.

303
00:18:19,333 --> 00:18:25,108
No, indeed, because you manage how these are called through your main SKILL.md.

304
00:18:25,108 --> 00:18:27,430
And then each skill is going to be a folder.

305
00:18:27,430 --> 00:18:31,515
So here we have the PDF skill, the basics, you need the SKILL.md.

306
00:18:31,515 --> 00:18:32,847
And then it's free.

307
00:18:32,847 --> 00:18:35,649
they are quite lenient into what you can do.

308
00:18:35,649 --> 00:18:37,010
think this forms dot MD.

309
00:18:37,010 --> 00:18:39,733
It's also a reserved kind of file.

310
00:18:39,733 --> 00:18:40,875
have not used it myself,

311
00:18:40,875 --> 00:18:43,618
But they have a few tips into how to do it.

312
00:18:43,618 --> 00:18:47,360
Like don't nest too many folders or not, you know, on this kind of things.

313
00:18:47,360 --> 00:18:54,846
they, they go through what is a good skill pattern or how to split the information, how to
reference.

314
00:18:54,870 --> 00:18:59,853
one thing that I've seen recently is that they have done the same, but in a more visual
way.

315
00:18:59,853 --> 00:19:04,921
they, they release this kind of, I don't know, nice PowerPoint, let's say.

316
00:19:04,921 --> 00:19:06,342
More of a book almost.

317
00:19:06,342 --> 00:19:09,043
Yeah, and it's planning and design.

318
00:19:09,043 --> 00:19:10,514
but it has a lot of examples.

319
00:19:10,514 --> 00:19:13,734
Testing, for example, is an important part of skills.

320
00:19:13,734 --> 00:19:18,034
Everything that you do with LLMs testing is quite difficult because they are
non-deterministic.

321
00:19:18,034 --> 00:19:21,615
You cannot do two plus two equal fours, simple unit test.

322
00:19:21,615 --> 00:19:26,126
So it's something that you need to pay quite some attention to be honest.

323
00:19:26,126 --> 00:19:28,438
But yeah, they give you good examples on how to.

324
00:19:28,438 --> 00:19:35,764
Finally, one interesting thing, even though I don't like it too much, is that Anthropic
provides you a skill to create skills.

325
00:19:35,764 --> 00:19:37,636
It's called a skill creator skill.

326
00:19:37,636 --> 00:19:41,458
So you can call it and say, hey, I want to do a skill to do this and that.

327
00:19:41,458 --> 00:19:47,792
And then they will trigger the skill creator, and then they will ask you some questions
and come up with the best skill using best practice.

328
00:19:47,792 --> 00:19:49,234
But you don't like it?

329
00:19:49,234 --> 00:19:53,100
My experience has not been great, but to start it's really good, I would say.

330
00:19:53,100 --> 00:19:57,273
I think I used it at one point where I had a long conversation to let it do something.

331
00:19:57,273 --> 00:19:59,305
And then I asked to make a skill out of this.

332
00:19:59,305 --> 00:20:02,317
And so it ended up with a skill that I could download as a zip.

333
00:20:02,317 --> 00:20:06,950
And then I had the same structure you had, but then I could start manipulating that
myself.

334
00:20:06,950 --> 00:20:13,716
And I thought it was a pretty okay starting point, but that was from a UI perspective that
was using the main Claude desktop UI.

335
00:20:13,716 --> 00:20:15,368
It was not using Claude code.

336
00:20:15,368 --> 00:20:16,210
OK, yeah.

337
00:20:16,210 --> 00:20:19,854
Yeah, I mean, I think it's a nice light-wave wrapper, guess.

338
00:20:19,854 --> 00:20:25,932
Like, if you point to the best practices and what you have in mind, you can get the same
of it even better.

339
00:20:25,932 --> 00:20:27,344
But it's good to start.

340
00:20:27,344 --> 00:20:34,682
It's a nice way to get like a scaffold, and then you can take a look at it and tweak it
however you wish,

341
00:20:34,682 --> 00:20:35,934
Okay, a few questions.

342
00:20:35,934 --> 00:20:38,085
What is the relation according to you to MCP?

343
00:20:38,085 --> 00:20:44,249
When would you use an MCP server to solve for something or to add to your agent or when
would you use a skill?

344
00:20:44,249 --> 00:20:50,366
I think for me, I see the value of MCP every time that you have to interact with an
external system.

345
00:20:50,366 --> 00:20:52,077
especially when you need authentication.

346
00:20:52,077 --> 00:21:00,742
For example, imagine that we have Notion in Dataminded and they provide an MCP so you can
plug your agent into Notion.

347
00:21:00,742 --> 00:21:04,834
But of course, you need to give permissions to say, hey, I am Jesus.

348
00:21:04,834 --> 00:21:06,216
I have access to Notion.

349
00:21:06,216 --> 00:21:08,959
Notion needs to make sure that you are who you say you are.

350
00:21:08,959 --> 00:21:10,811
But apart from that, I would...

351
00:21:10,811 --> 00:21:12,452
avoid MCPs.

352
00:21:12,452 --> 00:21:15,914
MCPs are also things that are quite difficult to create.

353
00:21:15,914 --> 00:21:17,786
They are engineering heavy.

354
00:21:17,786 --> 00:21:21,369
So if there are MCPs out of the box, that's nice to use.

355
00:21:21,369 --> 00:21:31,869
But even nowadays, it's even changing because agents can execute CLI commands, there are
integrations that you can do as a skill, bypassing this idea, where it says, hey, use a

356
00:21:31,869 --> 00:21:33,641
CLI of Notion to do stuff.

357
00:21:33,641 --> 00:21:39,035
use the CLI of Obsidian, for example, to that is a local note taker.

358
00:21:39,035 --> 00:21:41,156
For example, Obsidian, they have an MCP.

359
00:21:41,156 --> 00:21:43,787
And they also, Obsidian also has a CLI.

360
00:21:43,787 --> 00:21:52,382
For me, it's a bit of yeah, over engineering team to use MCP when it's local, you you have
Obsidian locally, you have your Claude Code locally.

361
00:21:52,382 --> 00:21:55,153
Just use a skill and say, use this few commands.

362
00:21:55,153 --> 00:21:56,906
That's way more efficient.

363
00:21:56,906 --> 00:21:57,427
Yeah.

364
00:21:57,427 --> 00:22:08,738
So do I read this correctly that you see MCP being deprecated in favor of the normal APIs
and CLIs and have that be used by a skill

365
00:22:08,738 --> 00:22:09,419
Not fully.

366
00:22:09,419 --> 00:22:18,558
think like as a developer skills, I would always say that is a good way to go unless you
really need this kind of more complicated integrations.

367
00:22:18,558 --> 00:22:30,692
However, I am working on a, on an end to end agent that does a bunch of stuff and we do
need MCP or at least we need a way to connect two different systems.

368
00:22:30,692 --> 00:22:39,664
and do proper authentication and keep the connection private in a private network and JWT
tokens and engineering stuff that it is needed.

369
00:22:39,664 --> 00:22:45,704
But if I am doing my day-to-day work or a hobby project, I will always try to use a skill.

370
00:22:45,704 --> 00:22:50,419
Yeah, so for personal productivity and automation, you would definitely go to the skill
route.

371
00:22:50,419 --> 00:22:50,930
Okay.

372
00:22:50,861 --> 00:22:52,142
how do you share these skills?

373
00:22:52,142 --> 00:22:54,044
You made this skill in a repository.

374
00:22:54,044 --> 00:22:55,396
It's just a folder.

375
00:22:55,396 --> 00:22:56,788
How can I now use them?

376
00:22:56,788 --> 00:22:57,786
That's a good question.

377
00:22:57,786 --> 00:22:59,546
There are two ways.

378
00:22:59,546 --> 00:23:04,986
So for example, if you use Claude Code, they have their own way of versioning skills,
sharing skills.

379
00:23:04,986 --> 00:23:07,686
So they use this concept of a marketplace.

380
00:23:07,924 --> 00:23:13,657
So you can create plugins that are basically a bunch of skills together, for example, or
agents.

381
00:23:13,657 --> 00:23:17,351
And then you can install them really easily.

382
00:23:17,351 --> 00:23:24,938
Another way is, yeah, if you clone a repo that they have a skill and you put it on your
.claude folder.

383
00:23:24,938 --> 00:23:26,039
And recently,

384
00:23:26,039 --> 00:23:34,825
Vercel came up with a kind of a marketplace because the things that skills now was created
from Anthropic, but they open source the specs.

385
00:23:34,825 --> 00:23:40,729
now everyone also if you use Copilot or OpenAI, ChatGPT, whatnot, you can use skills.

386
00:23:40,729 --> 00:23:42,070
So that's quite nice.

387
00:23:42,070 --> 00:23:49,555
And then here, Vercel came up with this kind of marketplace where you can upload your
skills and then people can find them.

388
00:23:49,555 --> 00:23:55,558
For example, recently I wanted to create a video and there is this library called Remotion
to create videos.

389
00:23:55,558 --> 00:23:57,991
So I found these skills and I downloaded it.

390
00:23:57,991 --> 00:23:59,272
And here you can see like

391
00:23:59,272 --> 00:24:00,836
what are the things that you have.

392
00:24:00,836 --> 00:24:03,023
I download it, and that's it.

393
00:24:03,023 --> 00:24:06,453
And you just start using it, and it's quite easy to interact with.

394
00:24:06,453 --> 00:24:13,401
And in your local setup, could you maybe point us to the .claude folder and show where you
installed them?

395
00:24:14,120 --> 00:24:16,083
So it is .claude.

396
00:24:16,083 --> 00:24:18,737
And here you see these are the skills.

397
00:24:18,737 --> 00:24:19,268
Yeah.

398
00:24:19,268 --> 00:24:24,588
But also you can go to your root if you want skills that are used across projects.

399
00:24:24,588 --> 00:24:31,448
in that folder you also keep track of the conversations and the subagents and permissions,
so it's not only the skills, let's say.

400
00:24:31,448 --> 00:24:32,893
All right, this looks really nice.

401
00:24:32,893 --> 00:24:36,014
think people can try it out themselves if they check out a repository.

402
00:24:36,014 --> 00:24:37,810
Anything else you'd like to add Jesus?

403
00:24:37,810 --> 00:24:39,453
No, just give it a try.

404
00:24:39,453 --> 00:24:42,439
think the barrier to try them is quite low.

405
00:24:42,439 --> 00:24:48,542
You don't need to do much engineering, but they can speed up your workflow significantly.

406
00:24:48,542 --> 00:24:49,975
That's how I feel it.

407
00:24:49,975 --> 00:24:50,386
Yeah.

408
00:24:50,386 --> 00:24:50,795
All right.

409
00:24:50,795 --> 00:24:52,347
Thanks a lot for explaining.

410
00:24:52,347 --> 00:24:57,953
There's many other aspects that we didn't cover like marketplaces, hooks and more advanced
concepts.

411
00:24:57,953 --> 00:25:05,190
We'll cover those in the other video where you will also showcase a bigger agent that you
build also using these skills principles.

412
00:25:05,190 --> 00:25:07,374
So thanks a lot for explaining us Jesus.

413
00:25:07,374 --> 00:25:10,447
And thank you everybody for watching and we'll see you next time.

414
00:25:10,447 --> 00:25:11,476
Bye bye.