Using the New Copilot Studio Skills

Microsoft's Copilot Studio now supports Skills, modular Markdown-based prompts with YAML metadata that can include Python scripts for deterministic outcomes. A developer highlights how Skills reduce token costs and improve LLM response quality by avoiding polluted context, and can be transferred across platforms like GitHub Copilot. The post categorizes Skills into behavioral, action, and knowledgeable types, and notes that Copilot Studio's built-in Python compiler enables consistent data processing, such as in a Power Automate Code Review Agent.

One thing Microsoft is not good at is naming things, and sadly it's happened again. But let's go back to the beginning: what are Skills? Skills are targeted prompts/context that are modular, so they are not always included in the LLM session. They are Markdown files with selected metadata in YAML, all in a file normally named skill.md the parent folder and YAML metadata identify it . They were created by Anthropic Claude and were designed for both the user to add in a prompt /Skill , or for the LLM to decide. Similar to Skills are Plug-ins. These can and often do include skill.md files, but can also have scripts, MCP servers, and other tools. So back to Microsoft naming things badly. Plug-ins include Skills, so why does it matter? Well, it doesn't really, but I like to moan, and it means sometimes cool functionality can be left on the table because we presume Microsoft names things accurately. Anyway I digress I like to do that , now we understand what Skills/Plug-ins are I wanted to dive into them within Copilot Studio and cover: I often go on about skills being cool, but why? There are a few reasons. Before skills, the standard approach was to give the LLM everything and let it figure out what it needed. The problem with this is twofold. First, more context equals more tokens, which equals more cost. Second—and more importantly—too much unrelated context can have a detrimental impact on the LLM response. LLMs work by using input tokens to predict the next token, so polluted input tokens can make the LLM predict the wrong next token this is a huge simplification, but you get what I mean . As skills are simple Markdown files, they can easily be transferred between different agents and even platforms—I use some skills in both GitHub Copilot and Copilot Studio . As skills are just natural language, you can literally use them for anything. They can be used to: Just to name a few. But that's real skills. What about Copilot Studio Skills? They have all of the above because Plug-ins have skills included , but they also have two more big benefits. This, to me, was a game changer when I learned about it. Copilot Studio has a built-in Python compiler, so Copilot Skills can include Python scripts that the LLM can use. Imagine this: you include an Excel file, and instead of trying to get the LLM to return consistent analytics through natural language, you can build a Python script to do it. You now get deterministic outcomes with LLM flair. My favourite implementation so far is a Power Automate Code Review Agent that uses Python to structure the definition consistently for the LLM to review. Again, this is about consistency. When we want our data output to be the same for example, a PowerPoint template or Word form , LLMs are not our friends. They will try to deliver what you want, but there will always be small variances. If you include a template file in your Skill, the LLM will always return the data in that format. So we can now agree Skills are cool, but how do we use them correctly? Knowing what type of skill you need is the first step. I think there are three types of skills: behavioural, action, and knowledgeable. These are skills that influence how the agent acts. Example: Always review your work with a 3 stage approach: - validate the goal has been complete - consider any broader impacts to the development workflow or infrastructure - check for any potential security issues If you identify any issues complete an update and repeat. DO NOT Repeat more then 3 times , at this point create a md file named review-comments with any issues you have identified These are when you want the agent to do a specific thing, it could be deploying or running GitHub Actions. But it is not limited to tools, one of my favourite is grilling / grill-me my Matt Pocock if you have no seen his skills you really need to . Matt Pocock Skills GitHub: grill-me https://github.com/mattpocock/skills/blob/main/skills/productivity/grill-me/SKILL.md Interview me relentlessly about every aspect of this until we reach a shared understanding. Walk down each branch of the decision tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer. Ask the questions one at a time, waiting for feedback on each question before continuing. Asking multiple questions at once is bewildering. If a fact can be found by exploring the environment filesystem, tools, etc. , look it up rather than asking me. The decisions, though, are mine — put each one to me and wait for my answer. Do not act on it until I confirm we have reached a shared understanding. As I said, in Copilot Studio these are actually plugins, which give you the incredible power of scripts. To use the script there are a couple of ways. You can provide them with references so that the agent reads them and decides when to use them. These are ideal for knowledgeable skills where the script adds data. The second approach is to explicitly tell the agent to call a specific function with specific input. These are great for action skills. To pass information into the script add imports, along with explanations of what they are in the actual skill file. To get the values returned we can either pass them straight into the context using print : Or we can create a temporary file and save data to that. Set output parameters for the function: parser.add argument "-o", "--output", help="Output JSON path" Skill sets the output to model.json : python scripts/extract.py <solution.zip -o model.json Then we just write what we want to the output. We can then use that file in other skills by using Python to read it. python scripts/review.py model.json --area Connections -o findings.json As you can see its relatively easy to pass data to and from python scripts, but what if you can't write python, well that's when a little vibe coding can come in useful. In my experience LLM's are pretty good at writing python, but I've found them even better at converting between languages. In the above example everything was converted from some JavaScript I had written, and I had zero issues. Once you have Skills you need to understand how to use them within your agent. There are three main ways for a skill to be called. The instruction file will state which skills should be used and when. This is the most simplest and consistent way to use Skills. You set out what conditions to use them and why. The top of every skill in YAML contains the name and description, the LLM will be passed these and it can then makes its own decision when to use them. This gives the best flexibility and empowers the agent, but with the loss of consistency/deterministic outcomes. Just like an instruction, Skills can call other Skills. The main benefit of this approach is enforcing chains/processes. As because its not in the instruction file the LLM will not be passed it unless there is a need, keeping the context clean and focused. As you can see, Skills Plug-ins bring so much power to your agent, they: