0:01Over the last two videos, we built this agent loop and gave it eight tools, for working with files and for reaching the web.
0:07What it doesn't have is what your team knows: the rules you follow, your conventions and style guides, and what counts as done.
0:15The model never saw any of that in training, and much of it isn't in the code for the tools to find. So how do we give it to the agent?
0:23The first place is the task itself.
0:25That works, but the rules have to be written into every task, again and again.
0:31And whoever writes the task has to know them, which the person asking often doesn't.
0:37The second place, and the one most of us would reach for, is the system prompt. It's there at the start of every task.
0:45But not every rule applies to every task. The system prompt goes along on every call of every task, so each rule takes up context whether the task needs it or not.
0:57And it grows with everything the team adds, so the more we write down, the more every call carries.
1:03The third place is a document the agent loads only when a task needs it.
1:08We write the knowledge down once, in a file beside the agent's code.
1:12The system prompt carries only one line about it: a name, and when it applies.
1:18The rest comes in when a task needs it, so the prompt stays short however much the team writes down.
1:24For agents, this is called a skill. Like a skill a person picks up for a job, the agent takes it up when the work calls for it. Let's see how that works.
1:34A skill is a folder holding one Markdown file.
1:37At the top of the file are its name, and a one-line description of when the skill applies.
1:43Below them is the body, which is the instructions themselves.
1:47When the agent starts, it puts only the name and description of every skill into the system prompt, one line per skill.
1:54So from the first call, the model knows which skills exist and what each one is for. The bodies aren't in its context yet.
2:01When a skill's description matches the task, the model calls load skill.
2:05Load skill reads that skill's body, and it comes back to the model as a tool result.
2:11From then on, those instructions are part of the conversation, and they stay there until the task is done.
2:17In our agent, the model decides when a skill applies.
2:21Some agents also let the user load a skill directly, with a command, and the model doesn't choose.
2:26Now let's look at the three skills our agent gets in this video.
2:30The first is the team's style guide for punctuation.
2:34The second is the team's policy for links: which addresses may become links, and what every link has to carry.
2:41And the third is about the Markdown spec the project follows.
2:45This video's task needs only the first, and the others are for later videos. Now let's look at the code that loads them.
2:55This video's code is in the skills folder, and two things are new. A dot skills folder, which is the library, and skills.py, the code that loads from it.
3:07Three skills, one folder each, and each folder holds one skill file.
3:13Let's start with the code. It's about fifty lines.
3:16With the docstrings hidden, it's one setting and three functions.
3:19The library is the dot skills folder, beside the agent's code and outside the sandbox, so load skill is the only way to it.
3:27Parse skill splits one skill file at its dashed fences: the lines on top become a dictionary, and the rest is the body.
3:35Skills index walks the library and writes one line per skill, the folder's name and the description. That's what the system prompt gets.
3:44Load skill is a tool, defined with the same decorator as the others. Its description tells the model when to load one.
3:51Given a name, it finds that folder and returns the body of its skill file. An unknown name gets an error that lists the real ones.
3:58Now let's see the three changes this makes to the agent file.
4:03This is the agent file, and everything in it is the loop from the last video, with three small changes.
4:10Comments hidden, let's find them.
4:11First, at the top, the import from skills.py: the load skill tool, and the index.
4:18Second, right after the system prompt is loaded, one line appends the skills index to it, under the heading Available skills.
4:25Right below is this video's task. We'll come back to it just before the run.
4:30Everything between here and main is the loop we already have, so let's hide it.
4:35The third change is in main, where load skill joins the tool list. Those are all three, and the loop itself is untouched.
4:43The system prompt has one new section too.
4:46This is the prompt every episode shares, and the new part is near the top.
4:51It tells the model to load a skill when its description fits the task, and to do that before changing any code. Once loaded, a skill stays in force until the task ends.
5:02Now let's look at the skills themselves.
5:05We'll go through one of the three here. The other two are in the code, for you to read on your own.
5:12This one is specific to our project: the punctuation rules of the team behind md2html. What to look for is how a skill is laid out.
5:21On top, the name and the one-line description. That line is all the model sees until it loads the skill.
5:28Some of the team's rules differ from the usual conventions, and that's why they're written down.
5:33Then the rules themselves, in plain words, grouped by topic, each with a short example.
5:39It also says where the rules don't apply.
5:43And it ends with two worked examples, so the model can check its output against them.
5:49The other two skills follow the same layout.
5:51That's the library. Now let's put the agent to work.
5:54First, the task in full, as the agent gets it.
5:59We want md2html to apply typographic punctuation to a document's text. Straight quotes become curly quotes, hyphens become proper dashes, and three dots become the ellipsis character.
6:14And it has to follow the team's style guide, exactly as the guide states it.
6:18Nothing may change inside code or in link addresses, it goes in as a new extension, and it comes with tests.
6:26Now let's run it.
6:27Same run command, pointing at this video's folder, plus a new flag at the end.
6:32The grade flag runs tests the agent doesn't know about. They're called held-out tests.
6:38We wrote eleven, one for each rule in the guide, and they're kept outside the agent's sandbox, so it can't read them.
6:43When the agent finishes, they're copied into the sandbox and run against its work.
6:48Video seven is about verification, and we'll see there how this works and why it matters.
6:52Let's start the run.
6:56Okay, the agent is at work. We'll let it go, and cut to the end.
7:01It's done.
7:03The totals are at the end again: twenty model calls, and about a million tokens in. We'll come back to these.
7:09And below them, the grade: with our eleven tests added, eighty-nine tests pass.
7:14Before the bill, let's see what the agent says it did.
7:18It wrote the extension as a hook on the renderer. Every piece of text in the document passes through it before it's written to the page.
7:26Its dash rules match the guide, including the one that differs from the usual convention.
7:32And because it only touches text, code spans, code blocks and link addresses are left alone without any special case.
7:40Let's take a closer look at the bill.
7:44Here's what this run cost. Twenty model calls, and twenty-eight tool calls, one of them loading a skill.
7:50Just under a million tokens went in, and forty-five thousand came out.
7:55Most of that output is the model's reasoning, in three long calls just before it wrote the extension.
8:01The style guide is under four hundred tokens, and once loaded it goes along on every call, about seven thousand in all.
8:08The two skills it didn't load cost only their line in the index.
8:12The run took about six and a half minutes, most of it in those same three calls.
8:17And afterwards, the grader's eleven tests, one for each rule in the guide, all pass.
8:22Here are all twenty-eight calls, in the order the model made them.
8:26The second call loads the house typography skill, and it's the only skill this run loads. Its result is the guide's full text.
8:34Then it reads the extensions, the renderer and parser, and the tests, and checks the test fixtures for quotes the new rules could change.
8:42It writes the extension in one call, registers it with two edits, and writes its tests.
8:48At the end, it runs the tests, renders a sample with and without the extension, and runs the full suite once more.
8:58Now let's try the typography extension on a real document.
9:02These are release notes, typed the way the team types: straight quotes, plain hyphens, three dots.
9:09Here we expect the quotes to curl, the year range to get an en dash, and the three dots an ellipsis.
9:16And the spaced hyphen after the range should become a spaced en dash, the team's own rule.
9:21In the list: another spaced hyphen, three hyphens for an em dash, and a code span that must stay as typed.
9:28The code block and the link address stay as typed too.
9:31Now let's run the agent's md2html on it.
9:35Same render script as before, pointing at this video's sandbox.
9:40The page is written next to the notes. Let's open it.
9:45This is the page our agent's md2html made from those notes.
9:49The quotes have curled, the year range has its en dash, and the dots are an ellipsis. The spaced hyphen became a spaced en dash, following the team's rule.
9:59In the list, we get another spaced en dash and the em dash, and the code span is left as typed.
10:05And the code block keeps its straight quotes and double hyphens.
10:10Our agent built the whole feature, and the rules it followed came from the skill.
10:14It loaded the team's guide, and only that skill, before reading any code. It chose it from the guide's one-line description in its prompt.
10:22Then it wrote the extension and thirty-six tests of its own, following the guide.
10:26And our eleven held-out tests all pass, including the dash rule that only the guide states.
10:34That's skills: knowledge your team has, that the model loads only when a task calls for it.
10:39In the next video, our agent hands parts of a task to other agents, called subagents, each with a context of its own.
10:46I'll see you there.

Skills

Created by Abhyuday DesaiPublished 7 Oct, v1Runs 10 min 59 sec

0 views

About this video

The third build of Building AI Agents. A model knows what it learned in training. It does not know your team's conventions, the rules you follow, or what your team counts as done, and often none of that is written in your code either. This video is about how you hand that knowledge to an agent.

The two obvious places both fail. Put the rules in the task, and whoever writes the task has to know them, every time. Put them in the system prompt, and every call of every task carries them whether that task needs them or not, so the prompt grows with everything your team writes down.

A skill is the third option: a folder with one Markdown file holding a name, a one-line description of when it applies, and the instructions themselves. Only the name and the description go into the system prompt. The instructions arrive when the model decides a task calls for them. The prompt stays short however much you write down, and the agent loop does not change at all.

You'll see:

Why the task and the system prompt are the wrong place, and what each one costs you
What a skill is, and how the agent chooses one: the index it sees at startup, and the tool that fetches the rest
The fifty lines that implement it, and the three changes to the agent
A run where the agent loads one skill, and only that one, before it reads any code
What it costs: a loaded skill rides along on every later call, while the ones it never loads cost a line each
Whether it actually worked, judged by tests the agent was never allowed to see, including a rule it could only have got from the skill

The next video gives the agent subagents: parts of a task handed to other agents, each with a context of its own.

What changed

v107 Oct 2026abhydesai10 min 59 sec17e81d3

First published cut

0 views0 likes on this version