Log In to continue learning
Agent Skills with Anthropic
Beginner
2h19m
Topics
Agents
In the previous lesson, we saw how to create skills in Claude and move from prompts with data to package skills that we can use across many different conversations. Now let's dive deeper and talk about what skills are and the open standard that powers them. Similar to the model context protocol, skills themselves are an open standard that can be used across many different AI applications. While skills were something originally created at Anthropic. Skills themselves are now an open standard with a specific specification that is used across many different platforms, including Codex, Gemini CLI, Claude Code, Open Code, and much more. With that in mind, let's talk a little bit about how this works. When we build AI applications, in order to use particular skills, we need to make use of some kind of file system when using tools like Claude AI or Claude Desktop. In that file system, we load folders that contain a SKILL.md file and subfolders or files that can be referenced. Here we can see exactly what we did previously. At the same time, skills themselves cannot only include other markdown documents, but scripts that can be executed. For example, we have a skill for working with PDF documents. we need to convert PDFs to images, extract info from form fields, and even fill PDF forms with annotations. This requires code to be executed. But that code that needs to be executed can be referenced from the SKILL.md file. So as we start to explore our own custom skills and built-in skills, it's important to note that skills are not just text files that reference other text files, but text files that can reference scripts, what they do, and when they need to be executed. Skills can also include icons, images, and other assets as we start to think about ways of creating custom styles and brands. Where skills really shine are places where Claude might not know exactly how you or your company operates. You can imagine designing newsletters, creating brand guides, things that Claude has a general idea on, but not the exact way that your company or your team does it. To give some more idea of why we bring agent skills into the mix when we're building our own agents. The way that we used to think about building agents centered around agents with a single purpose. Coding, research, finance, marketing, and much more. These domain-specific agents had a particular set of tools, the context that it needed to perform the task necessary. But as we started to build more of these single-purpose agents, we started to realize that under the hood, all that they really need is a simple scaffolding. Underlying tools like bash and a filesystem, to find, edit, modify, execute, and perform whatever tasks are necessary. These simpler agents are easier to evaluate, understand, and scale. But what these agents lacked was the underlying context and domain expertise to do the job reliably. That context can be provided through skills, through the model context protocol, but that domain expertise is really where skills shine as well. We want finance agents to perform financial analysis in a particular fashion. We want research agents to have the domain expertise necessary to research the way that we want. to be able to port that across many different ecosystems and agents, and that's why we have agent skills. These skills provide us the procedural knowledge and the user-specific context that they can load on demand. In addition to domain expertise, skills can also provide a repeatable workflow. In a non-deterministic system, where we don't always know exactly what the output of the model is going to be, it can be difficult to find repeatable ways of producing the same output. What skills allow us to do is provide a repeatable workflow. with very articulate steps or instructions that allow the agent to perform a task that we can start to predict with more accuracy. Skills also introduce the idea of new capabilities, things that an agent does not know how to do out of the box or even data that Claude has no idea how to operate on. When we bring in these new capabilities, we unleash an entire ecosystem and new functionality for our agents with minimal additional context. As we think about domain expertise, we want to lean on things that Claude might not know how to do or knows how to do but not for your particular domain. Claude can perform data analysis. Claude can perform legal review. But how does it do it the way that you or your team or company want it to be done? We previously saw the ability to perform weekly marketing campaign reviews, and we want that to be predictable across many different individuals and teams. As we start to think about some of these new capabilities, things like generating presentations, Excel spreadsheets, PDF reports, executing scripts when necessary to perform those actions, that here is where agent skills can shine. What we saw previously, without skills, was the idea of describing our instructions, trying to predict workflows and bundling all of the necessary files in context at one time. We talked a little bit about the portability of skills. And while we've seen skills so far in Claude AI, skills can be used in the exact same format, not only across Claude Code, the Agent SDK and the API, but since Agent Skills are an open standard, you can use this across a growing number of agent products. You can create skills in one environment and use them and share them and scale them across many different environments. When we say that skills are composable, this is something that we've seen already. We can take custom skills like analyzing our marketing campaign and we can combine that with built-in skills like creating PowerPoint presentations, PDFs, or Excel spreadsheets. Not only can we use multiple skills together, but we can combine them to build complex and predictable workflows. We can reference the skills necessary, the steps necessary, and start to create predictable outputs in a non-deterministic system. Under the hood, skills can contain quite a bit of information. We saw examples with additional markdown files and even examples with scripts that can be executed. You can have hundreds of skills across your system, and what we're going to see quite a bit more is that to protect the context window, skills are progressively disclosed. The idea of Progressive Disclosure is to only load the data necessary and avoid polluting the context. We like to think of the context window as a public good. The more data that we add to the context window, the more tokens we consume, the faster our context window fills up, and the likelihood of context degradation or incorrect responses potentially increases. In order to avoid polluting the context window with data that we might not need, skills introduce the idea of Progressive Disclosure. When skills are loaded from the file system, the only data that gets added to the context window is the name and description of the skill. This is essential so that Claude or any other system knows what the skill is and how to trigger it. Once that skill is triggered, the underlying SKILL.md is loaded. This is the next phase of loading data into context. And depending on what is required, if there are additional files or scripts that need to be loaded and executed, those will be loaded progressively. These additional resources can be loaded as needed, and if there are scripts that need to be loaded, those scripts are loaded and executed separately from the context window to avoid polluting with additional tokens that are not necessary. By using tools like bash and a file system, Claude can load only the information that's necessary, execute only scripts and reading of files that is necessary, and intentionally only add what is necessary to the context window. In the next lesson, we'll continue talking about skills and particularly how they're used alongside other technologies like the model context protocol, sub-agents, underlying tools, and much more.
