---
type: raw-transcript
title: "Claude Skills Aren't Just for Claude - Here's How to Build Them for ANY Agent"
youtube_id: -iTNOaCmLcw
url: https://www.youtube.com/watch?v=-iTNOaCmLcw
slug: claude-skills-arent-just-for-claude-heres-how-to-build-them-for-any-agent
published: 2026-01-28
duration: "0:24:28"
fetched_at: 2026-07-21
immutable: true
---

## Transcript

**[0:00:00]** It hasn't been that long since Anthropic released skills to the world and it is one of the most important advancements in AI recently. And honestly, one of the biggest reasons it is so important is because of how beautifully simple it is and that is the motto of anthropic. The simpler the better. We see this looking at Claude code as well. I mean, when you get into how skills work and the idea of progressive disclosure that we'll get into, you can't help but thinking to

**[0:00:27]** yourself, why in the world was skills not commonplace ever since generative AI was a thing? And people have been building their own version of skills before anthropic popularized it. It's super easy to incorporate the idea of skills and progressive disclosure into any AI agent or tool that you want. And that, my friend, is what I'm going to show you how to do today. Because here's the thing, and a lot of people don't realize this. We are not limited to the clawed ecosystem to take advantage of

**[0:00:56]** skills. Anthropic does get a lot of credit for popularizing the idea, and we'll get into some of their best practices for creating skills as well. But this really is a universal concept. It's all about strategizing how we can allow the agent to discover context and capabilities as it needs it to be more flexible and context efficient as opposed to something like an MCP server or super long global rules where you're just dumping a bunch of context into the LLM right away and completely

**[0:01:22]** overwhelming it. So, as much as I really appreciate the anthropic ecosystem like Claude Desktop and Claude Code, we don't always want to be limited to these platforms because a lot of the time you want to build skills into your own workflows or AI agents. You want to use different large language models, maybe even local AI. There's so many reasons to incorporate skills into our own systems and really build it out for oursel. And that's what I'm going to show you how to do. We're going to take

**[0:01:48]** all of the concepts from Enthropics version of skills and we're going to map it into our own AI agent with the system prompts and the tools we give it. And it's beautifully simple, right? Simple but powerful. And so this is only going to take like 10 to 15 minutes. And then you'll know after that exactly how to build this kind of thing into your own systems. And I've got a template for you of course as well. All right. So there's three things I want to cover with you in

**[0:02:11]** the next 15 minutes. It's going to be super valuepacked. So, first we need to get into at a high level how skills work and why they're so powerful, even if you've used them before. Going over this is going to be really valuable. Then we'll get into the template that I have for you. This is a GitHub repo that of course I will have linked in the description. And so, this is a demonstration using Pyantic AI as my agent framework, how we can build our own idea of skills into any framework

**[0:02:36]** that we want. And so I'll go over how I'm building this with Pantic AI, but the concept here is going to work no matter what tool you end up using like Langchain, Crew AI, Eggno, no framework at all, literally anything that you want. And then just as an opportunity here to show you how far we can take our custom agents, I also want to get into evals and observability. So how can we make sure our agent is really following all the instructions and capabilities that we give it? And so in our case

**[0:03:03]** right here, that it's truly leveraging the skills that we give. And so I'll get into that at the end just as a bonus on top of everything showing you how to build skills for yourself. All right, so now let's go over a really really quick master class on skills, what they are, why they are so important. So Anthropic has this article that I'll link to in the description, a really good guide, and they cover best practices for building skills that we'll talk about in

**[0:03:26]** a little bit. And so the problem skills are solving. We want to give our agent a lot of different capabilities to supercharge them, but we don't want to overwhelm their context window. Agents are very prone to being overwhelmed when we give them a lot of information through our tools, conversation history, the system prompt, everything goes in the window. And so other methods like MCP servers, the problem there is we're giving a ton of tools up front to the

**[0:03:53]** agent even if it never needs to use them in a specific conversation. That is bad. And so with skills, the best way to explain it is to go to a diagram here in the article. And I also of course have it blown up in another tab right here. So the beautifully simple power of skills is the idea of progressive disclosure. Instead of giving all the tools up front to our agent like MCP servers, we are allowing our agent to discover the capabilities over time as it actually needs them. And so the only

**[0:04:23]** thing we're giving to the agent right away in the system prompt or you can think of it like the global rules is the description of the capability or the skill. And so in this case as an example we have a PDF processing skill. So we're just telling the agent, hey you have this capability if you need it. If the user actually asks you to do something with PDFs and then if the agent receives that kind of request and it wants to leverage the capability then it'll read

**[0:04:48]** the skill.md. So the skill.md this is the main file that drives any skill that you'll see from anthropic and all the ones that we'll go over with our custom implementation here. And so this has the full instructions for the capability. Now it's starting to load in the context. It's the second layer of progressive disclosure, right? Like the description is layer 1. This is layer two. And then there are some other documents oftentimes that the skill.md will reference. This is the third layer

**[0:05:16]** of progressive disclosure because we can load in even more context. If you want to get even more specific about something with PDFs, for example, like we have this extra set of instructions for if we need to fill out some form, some PDF form, right? Like not all the time we're working with PDFs do we care about this, but sometimes we do. So, we're just discovering more and more context over time as we actually need it for the task at hand. And that saves the

**[0:05:42]** LLM from being overwhelmed because if it had all these documents and a dozen other skills loaded all at once, it would be tens of thousands of tokens just to tell it right away all the different capabilities that it has and it probably only has to use one or two of them in a single conversation. All right, so with that explanation, I want to now get into the template and exactly how we are translating the ideas from anthropic into our own agent implementation. And again, I'm using

**[0:06:06]** paidantic AI because it is my favorite AI or agent framework. It has been for over a year now. And so starting off, we have the YAML front matter description, which by the way, as far as best practice goes, it's good to have this be somewhere between 50 and 100 words. You don't want to load in too much right away, right? That defeats the purpose of skill. So you want to be pretty short, but at least descriptive enough so the agent knows when it should leverage a

**[0:06:31]** capability. So usually the skill is, you know, something around 5% of the total context of the skill. That's all you're loading up front. Obviously, this is a very very rough estimate. And so when we think about our description here, essentially every single skill that we want our agent to have access to, we need it to have the description and the path to the skill in the system prompt. And so we're going to be taking advantage of what is called a dynamic system prompt. We have our static

**[0:07:00]** content, the main instructions for our agent that doesn't really change. But then also, we're going to collect the descriptions from all YAML front matters, all of our skill.mds, and we're going to put that in our system prompt. And I'll even get into the code just a little bit with you and show you how that works after we go through this diagram here. And then we have our skill.md, the main instructions for the capability. And as far as best practices go, usually you want this between 300

**[0:07:28]** and 500 lines long. Now, obviously that varies a ton depending on the complexity. It could be a lot shorter as well, but usually around 30% of the total context for the skill if you have a lot of reference files. Sometimes you don't even need this third layer, by the way, if the capability is simple enough. But anyway, as far as how this translates to our own system, our own agent, we just need a simple tool. Typically, this load skill tool is going to take a path to the skill.md. And so,

**[0:07:55]** the agent can invoke that. It can give the path which should be in the system prompt. And then we're just going to take the skill.md and return that as the tool response. And so now that is included in the context for the agent because every single time we call a tool, whatever it returns is now in the short-term memory for the agent. It is that simple. So remember, system prompt has the description and the path to the skill. So it has all the context it needs to know when it should leverage

**[0:08:22]** the skill and then what parameter to pass in as far as the path so it reads that file. And then in the skill.md we might also have references to our reference files the third layer progressive disclosure the scripts and markdowns to read and leverage to take the capabilities even further. And so I have a second tool in my system for this to read a reference document. And so you just give as the parameters here the skill and then the path to that secondary file that you want to

**[0:08:50]** leverage. And so this is where you have unlimited depth. I mean you could have a fourth layer progressive disclosure if you want but that probably gets way too complicated. So the rest of your skill will just live in these files. And I could combine these tools together. They work very similarly because it's mainly just to read a certain file. But in my experience from the testing I've done, it's helpful to the agent to know this distinguishment. Like this is the main

**[0:09:14]** instruction set for your capability. And that's it. I told you it would be simple. And I'll also show you the code for the Pantic AI agent in a little bit after a demo. All these different skills that I have incorporated into the template that I have for you. There's quite a bit. Like you could extend this to dozens and dozens and dozens and the agent would still work well because there's just that little bit of context taken up front for each of the capabilities. All right, so I have my

**[0:09:41]** custom Pantic AI skills agent loaded up here in the terminal. This is my playground to test out all the different skills that I have incorporated. And I can just drop any skills that I want into a skills folder just like you can with Claude Code. And so this is using the template that I'll link to in the description. I've got instructions here explaining how the skills work and a quick start. Very, very easy to get this up and running. Feel free to use this as

**[0:10:07]** a resource. Give it to your AI coding assistant if you want to incorporate this all for yourself. I also use the idea of a tool set in Pinantic AI. So, you should be able to pull that out and add skills into your own agent very easily. Yeah, go ahead and take a look at this. So, when I start the terminal, it is reading all of the skill.md files in my skill folder. It is loading all these skills and so I can use any one of them now. So for example, I can say help

**[0:10:33]** me find a good dinner dish with chicken. So it's going to use the recipe finder and I have all the logs here on purpose just so we have visibility into what's going on. So you can see it really is using the tool because we're loading the skill recipe finder. And then from that we have instructions to understand how to leverage some kind of API that this capability gives us. And so now it's making that request to help get me get some recipes that have chicken in it.

**[0:11:01]** And take a look at that. I found lots of delicious chicken options for you. And wow. Okay, now I'm hungry. All right. But anyway, now I can say like what is the weather in uh Tokyo, Japan right now. And so we'll see here that it's going to leverage another skill. So there we go. It's loading the weather tool. And then it's going to make an API request. And the only reason it knows how to do this is because of the instructions that we have here. And I could even tell it to like uh load the

**[0:11:29]** ref document for the weather skill because there's the third layer progressive disclosure if it needs more information. I have this API reference. So it can make more complicated requests. And so that's a little bit forced there, but I'm just trying to show you an example of the third layer of progressive disclosure as well. So really, really cool. And the important thing here is that based on our conversation with the agent, we probably only need to leverage one or two of

**[0:11:54]** these at a time. I chose different skills that are very different from each other on purpose here to drive home the point that like most of the time we don't need all of this. So if we had an MCP server for every single one of these, we would just be overwhelming our LLM for no reason. Okay. So now I want to get into the code a little bit with you to show how things are working under the hood. And even if you're not super technical, I'm going to keep this high

**[0:12:18]** level. I'm just going to show you how we're able to leverage this agent, how you can use this for yourself. So, first of all, in the readme here, I've got instructions to set everything up. And you can change this in your environment variables. One of the things you can specify is the directory where it searches to load all the skills dynamically into your agent. And so just to keep things as similar to the anthropic implementation as possible, I have the skills directory just called

**[0:12:43]** skills just like you have in cloud code for example. And so there's a folder in here for every single one of the skills that we have. This looks just like the anthropic skills where we have a skill.md. This is our YAML front matter. This is the description that's loaded into the agent up front. I'll show you how that works with the dynamic system prompt. So the agent knows like, okay, if I want to use a weather API, let me read this entire skill. MD file so I can

**[0:13:07]** use the API and I know how to do so. And then the third layer of progressive disclosure is optional, but for a lot of these, we have the reference folder for code review. We even have some Python scripts that we can use. And so all of these reference documents are called out in the skill.md so the agent knows it can go deeper to get those. And then for some like the world clock, we literally just have a skill.md because this is just really like for converting time

**[0:13:30]** zones. Obviously, we don't need that much context for the agent to know how to do that. And so it's just a pretty simple skill.md only a couple of hundred lines long. And so the way that this works, I have my pideantic AI agent. I have a lot of other content on my channel covering Pyant AI. So I won't go too much into the weeds here, but we have our agent definition, which by the way, this agent you can use Open Router, O Lama, or OpenAI, easy to extend it for

**[0:13:56]** others as well. So again, not stuck to the clawed ecosystem. And what we're doing here is we are creating a dynamic system prompt. And so when we first define the agent, we're not setting the system prompt at all because we're going to do it right here. And so in pineanti the way the way that you do this is you reference your agent dotsystem prompt. This is our Python decorator. Now the function below this is where we get to define the system prompt for our agent.

**[0:14:22]** So we can inject things at runtime because what we're doing with this line of code right here is we're calling a function that I'm not going to get into the weeds of that is going to search this skills directory. It's going to find every single skill.md take the YAML front matter. It's going to extract that from the skill.m MD and then put it into the system prompt. And so we have all of the descriptions of the skills and their paths as well as our primary system

**[0:14:49]** prompt. So we still have our base instructions that don't change. In fact, a lot of my instructions here is just telling the agent how to use skills. So it's very important. Large language models by themselves do not understand how to leverage these capabilities. What Claude did and what we have to do oursel is be very descriptive here. Like here's what skills are. Here's the metadata so you know the ones that are available to you. And then here is step by step how you leverage a skill when the

**[0:15:14]** description is screaming out to you that you want to use that capability. So all the prompting that I went over here is the first layer of progressive disclosure. The dynamic system prompt is how we are letting the agent know about everything upfront. And so then we get into our tool set. And so I'm giving a single tool set to my Pantic AI agent that has everything it needs to work with the skills to basically read everything we have in the skills directory. And so going to that

**[0:15:41]** definition here, there are three tools that we are giving. So we have the load skill and read reference. And then one other tool that I have here just to make it easier for the agent is to list the reference documents just in case the skill.md doesn't reference it directly at that at least then our agent is still able to find it. So we're just trying to make it as easy as possible to discover everything. That's the whole point of skills is discovering the capabilities

**[0:16:09]** that it has access to. And so for example, to load a skill, we just have to give the name of the skill. That's one of the things that's included in the system prompt. And so what we do here is we have our skill path that's set in our environment variable and then we have the name and then we're looking for the skill.md there. And so we're loading all of that and then we're returning the content of the skill.md. That's how we're including it now in the context

**[0:16:33]** window for the agent going forward. And it's very similar for when we're reading one of our reference documents as well. The code is actually almost identical, but there are some differences there to make sure that we're reading a reference document specific to the skill. some protections that I have in place for the agent. And so, yeah, that's pretty much the agent as a whole. Like, that's that's how it works. It's super simple in the end. And also, because I have

**[0:16:57]** this as a Pantic AI tool set, you can take this tool set, like you could copy this file and then just a couple of these other ones here, and you could bring this into your own Pantic AI agent in just a couple of minutes. And your AI coding assistant could help you do this so incredibly fast. So, please use this as a resource for yourself. just give it this repository and say like, "Hey, I have all these skills." You can put like literally any skill that you want in

**[0:17:21]** this folder right here and then the next time you interact with the agent, it'll have those capabilities automatically. So, very dynamic system that I built for you. Really good starting point for any kind of system you want to create. Now, one other really important thing to cover here is how you can build your own skills. And so, this guide that I have linked in the description is a really good starting point. Another quick tip that I have for you, super useful. If

**[0:17:44]** you go in Claw Desktop, you can use it to help you build your skills that you can then bring into the skill directory for your custom agent. So, you just go to file settings and then capabilities. You scroll all the way down to skills, go to example skills, and you can toggle on the skill creator. So, this is really meta, but this is a skill to help you build more skills. So when Claude uses this, it's going to pull in all the instructions and best practices for

**[0:18:11]** creating skills and guide you through that process. You can go here and say like, "Hey, help me build a skill for LinkedIn posting or help me build a skill to generate powerpoints or to create standard operating procedures, like whatever you need." And it'll walk you through creating that. And then it'll create a skill.md and then potentially some of those reference documents and you can take that and just put it in a new folder here in the skills directory. It is that easy to

**[0:18:34]** build your own skills and the sky's is the limit for the capabilities that you can create. All right, so at this point we now know the importance of skills and how to build them into any agent that we want. But the big question we have here is reliability. When we take these capabilities and you could have dozens of skills, you give them to your agent. How do you know that the agent is always going to leverage them when you want it to? Like you might have a skill for

**[0:18:59]** creating X posts, but you ask it to help you with content creation and it doesn't pull that skill because it doesn't know that content creation should mean that it should pull the X skill, right? Like you want to test for those things, but when you have dozens of different skills, it's really annoying to interact with the agent and send in a question and make sure it's using each one of them properly every single time you make changes to your agent. So that is where

**[0:19:21]** eval comes in. we can create an automated way to define questions and the expected tool calls or in this case the expected skills that it leverages. And so I'll cover what that looks like with you and then also get into observability. So when our agent is running in production using these different skills, we can look at how real users are interacting with our agent and making sure the agent is responding appropriately. And I'm pretty excited to get into this for the last

**[0:19:46]** part of the video here. I'm going to be pretty brief, but this is something I don't get to cover enough on my channel. Evals and observability are things that are super important, but I don't get to make content on it on my channel very much. So, luckily for us, Pideantic AI has a very robust evaluation framework built right in. And so, essentially what we can do is create these YAML files where we define all of our test cases. And so, for example, I'm going to send

**[0:20:15]** in the question, what's [snorts] the weather in New York right now? And then I have an evaluator to make sure that the weather skill was loaded. So we can also create our custom evaluators. I don't want to get into the code too much right now. You can read up on this in the documentation. Use this as an example for your AI coding assistant. But I have this custom evaluator to make sure that the right skills are loaded based on the questions that I send in. So now instead of me having to go into

**[0:20:40]** the agent and ask it each of these things to make sure it's using the different skills like the code review skill and the research assistant skill, now I can just run this single script. So I can call this Python script right here to run my evaluators. It loads in my golden data set as I call it. Goes through the questions one at a time. So, I am paying for the LLM credits, but these are really cheap, really fast, just a smoke test to make sure that all the different skills that I've added to

**[0:21:08]** my folder are actually being used properly by my agent. If it's not, then it means that maybe there's an issue in my loading capability or just my system prompt needs to be better or the skill descriptions need to be better. Like, there's definitely different things that need to be adjusted if the agent isn't working as you expect it to. And so eval are very important to run every single time you change the system prompt for your agent or even just the skills that

**[0:21:31]** you're giving it access to. So I also have instructions in the readme for how to run the evals. And you can feel free to poke around in the code for this as well if you want to see how to set this up for your own Pantic AI agents. But you want to do this for pretty much any agent you're deploying to production. Evals are so important and skills is just a good example because there's just so many different capabilities that we want to test for here. So logs are

**[0:21:54]** pretty verbose. Uh but I'm just using Haiku for all the tests here. So it's really nice and fast. But at the bottom here, 25 out of 25 cases have passed. And so I've sent in a lot of different requests to make sure the agent properly understands all of the skills that I've given it. So it's good to do this instead of having to do a bunch of manual testing myself after every single time I adjust my agent. So, I'll also link to this page for padantic evals in

**[0:22:20]** the description if you want to dive into this and really take your agent seriously before deploying them to production. And the other thing I want to talk about is observability with logfire because eval are great when you want to test your agent locally, but how about when users are actually using your agent in production, but you want to be able to peer into the traces as they're called to see the decisions your agent is making when people are using it out

**[0:22:41]** in the wild. And so, that's why we need a tool like Logfire. So it's created by the Pantic team. They also made Pyantic AI. So it's just a fantastic integration to have here. And it's really easy to set it up. And so there's just a minimal amount of code that I have to have in my agent definition file. So the logfire token is one of the environment variables. I explained that in the readme. And then we can configure logfire. So it's going to instrument all the podantic agents as in every time we

**[0:23:08]** invoke a tool interact with the LLM. It's going to send all of that as telemetry data. So we can track this running it locally like you're seeing right here, but then also in production. And so yeah, I'm also going to have a link to Logfire. I just wanted to mention this quick like this is so important being able to see our usage like token usage and cost in production. Looking into the different traces, like if a user reports a problem, we can go in here and see like, okay, where did

**[0:23:33]** the agent mess up? Like is it something wrong with their system? Did it just use a tool incorrectly like a bad parameter? We can look at all the parameters, all the tool calls that it made. So we can see the decisions even when we're not running the agent locally. It's very very important to have evals and observability when you want to take your agent seriously and paid with logfire and pantic AI just makes it so easy. So there you go. That is your guide for

**[0:23:57]** building skills into any AI agent that you want. And you even got a bit of a bonus with evals and observability because it is important to make sure we're constantly checking our agent making sure that it's leveraging our tools properly. Because with skills, we can give our agents dozens and dozens of capabilities like I've shown you here. So, if you appreciate this video and you're looking forward to more things on building AI agents, I would really appreciate a like and a subscribe. And

**[0:24:24]** with that, I will see you in the next
