How to use Agent Skills in GitHub Copilot

If agents are the whole Swiss Army Knife, Agent Skills are like each individual tool. Photo by Maciej Karoń on Unsplash

Overview

As of January 2026, Agent Skills are now available in the stable version of Visual Studio Code! This post will cover what Agent Skills are, why you might want to use them, and show an example of what it looks like to use them with GitHub Copilot in Visual Studio Code.

What are Agent Skills?

Agent Skills were released by Anthropic in October 2025, and they were published as an open standard in December 2025.

At their most basic, Agent Skills are simply markdown files of instructions on how the AI should do something, exactly the same as you would do in your copilot-instructions.md or an agent file. However, skills are focused on a single task for each skill, rather than putting all instructions in one place.

Why should you use Agent Skills?

To be clear, skills don’t offer anything new with AI that you couldn’t do before. However, in general, skills allow you to get more consistent results with AI than just putting everything in an instructions file or an agent. There are a few benefits to using skills compared to just those:

• They provide better organization. Skills allow you to essentially modularize your instructions file. Instead of telling it how to style, lint, unit test, and more in your instructions file, you can split those up into a skill for each use case, which also makes sharing instructions across different codebases/teams easier.
• They use less context. Skills are required to have a name and description in their frontmatter. Only these names and descriptions are put into your AI’s context initially, and the AI decides when to your skills based on those (just like it decides which MCP tools to run). If the AI decides to use a skill, it then loads the rest of the skill’s content into the context.
• They encourage the use of scripts for more consistent results. As we’ll see below, you can also add additional relevant files to a skill, including code, images, and more.

Like many things, we probably need to see an example of this in action to fully understand what it is and the purpose of it.

Enabling Agent Skills in VS Code

❗ At the time of this writing, you must enable Agent Skills in VS Code to be able to use them! Hit ctrl/cmd + , for the VS Code settings and search “agent skills” (you can also search by the underlying name of setting, chat.useAgentSkills). You should see an option that says “Chat: Use Agent Skills”. This needs to be checked to use skills, so do that before moving on.

Note that if your setting is called Claude Skills instead of Agent Skills, you’re on an older version of VS Code and need to update!

How to use Agent Skills with GitHub Copilot in VS Code

Let’s try out a skill ourselves. Agent Skills must be placed within a folder called skills inside the .github folder in your project (it can also use a .claude folder). Inside that, each separate skill also gets its own folder.

Let’s make a skill for unit testing. We’ll appropriately call it unit-testing, so its files will live inside the folder .github/skills/unit-testing.

At its most basic, each skill must have at least one markdown file called SKILL.md inside its corresponding folder. This file is the exact same concept as all the other markdown files you give to AI, such as copilot-instructions.md, in that it’s just plain English instructions to the LLM. However, the SKILL.md file is also required to have a frontmatter section with at least two fields: name and description. As mentioned above, these two fields will be used by the LLM to decide for itself when the skill should be used, which saves on your context window.

Let’s start with the SKILL.md file, which will be placed at .github/skills/unit-testing/SKILL.md:

---
name: unit-testing
description: Write unit tests following team conventions for naming, structure, and assertions. Use this skill when asked to write tests, add unit tests, or test a method.
---

## Process

1. Analyze the code to understand:
    - What class/method is being tested
    - What dependencies need mocking
    - What are the meaningful test cases (happy path, edge cases, errors)
2. Generate tests following the conventions found below
3. Each test should be focused on one behavior

...(rest omitted for brevity, look at GitHub repo at bottom of post for full skill)

This is all that’s required for Copilot to pick up the skill. Now, I’ll just ask Copilot about something related to unit testing and it should use the skill on its own:

Success! I gave it a very general prompt asking it to write some unit tests, and it found and used the skill. Pretty slick!

Improving the skill with additional files

You can also add more files for the skill than just the SKILL.md file, though! You can include runnable code, more markdown files, or any other assets (plaintext, images, SQL files, etc.). Inside the SKILL.md file, you tell it how and when it should use these additional files. The idea is that you can include things like a deterministic script for the skill to run to accomplish the task (along with any other files it needs) to have the AI give you more reliable results.

I’m a big fan of using AI to help me create deterministic automation, rather than try to automate directly from AI, so I’m going to add a Powershell script to this skill that will create a new test project for me if one doesn’t exist yet. In my experience, AI tries to do this, anyway, but with a script it will be consistent, always use the latest .NET version, and use the packages I like. A Powershell script can’t hallucinate!

I’ll call this create-test-project.ps1 and put it in the skill folder. Here’s what it looks like:

# Create a test project for an existing .NET project
param(
    [Parameter(Mandatory=$true)]
    [string]$ProjectName,           # e.g., "MyApp.Api"
    
    [Parameter(Mandatory=$false)]
    [string]$SourcePath = "src",    # Where source projects live
    
    [Parameter(Mandatory=$false)]
    [string]$TestPath = "tests"     # Where test projects should go
)

$testProjectName = "$ProjectName.UnitTests"
$testProjectPath = Join-Path $TestPath $testProjectName
$sourceProjectPath = Join-Path $SourcePath $ProjectName

# Check if test project already exists
if (Test-Path $testProjectPath) {
    Write-Host "Test project already exists at: $testProjectPath"
    exit 0
}

# Create the test project using xUnit template
dotnet new xunit -n $testProjectName -o $testProjectPath

# Add to solution
dotnet sln add $testProjectPath

# Add NuGet packages
dotnet add $testProjectPath package AwesomeAssertions
dotnet add $testProjectPath package NSubstitute
dotnet add $testProjectPath package AutoFixture

# Add project reference
dotnet add $testProjectPath reference $sourceProjectPath

# Delete the default UnitTest1.cs file created by the template
$unitTest1Path = Join-Path $testProjectPath "UnitTest1.cs"
if (Test-Path $unitTest1Path) {
    Remove-Item $unitTest1Path
}

# Rebuild
dotnet build --no-incremental

Write-Host "=== Test Project Created Successfully ==="
Write-Host "Location: $testProjectPath"

Nothing AI about this part – it’s just a normal Powershell script. As long as our skill calls it, AI can’t screw it up!

And, just to make the skill instructions a bit more readable, I’ll also split out the testing strategy into its own markdown file, testing-strategy.md. I won’t include that here, but you can go to the example repo at the bottom of this post if you’d like to see the entire skill.

At this point, SKILL.md only has information about what the skill does, when it should be run, and how to use the other two files.

Our skill folder structure now looks like this:

.github/
├── skills/
│   └── unit-testing/
│       └── SKILL.md
│       └── create-test-project.ps1
│       └── testing-strategy.md

Finally, be sure to reference all other files from inside your SKILL.md file, instructing it when and how to use them. File references should use relative paths from the skill root and only be one level deep. I’m also updating the skill’s description to also say that this skill can create the test project if it doesn’t exist yet:

---
name: unit-testing
description: Create unit tests, write tests, add tests, generate test cases for C# .NET code. Creates xUnit test project if one doesn't exist. Use for testing methods, classes, or adding test coverage.
---
...(rest omitted for brevity, look at GitHub repo at bottom of post for full skill)

Now, let’s test out the skill again with these additional files:

Even better! Not only did Copilot correctly use our skill, it saw that it should use the included script to create the test project since it didn’t exist yet.

When I ran this, it created 8 tests, which all passed. I’ll note that if this were a real app, I’d also tweak them a bit to change the test names and create the DiscountService mock at the top of the class, but I’ll leave them alone for this since I’m just showing how the skill works here.

That’s everything you need to start using skills! If you’d like to see the full files for this skill, check the GitHub example at the bottom of this post.

Cool, but when should you use Agent Skills?

In my opinion, everywhere you can think of!

To be blunt, the more I use Agent Skills, the less reason I see to use plain old agent files at all. In fact, you may even hear people making this exact point!

Current foundation models like Claude Opus 4.5 have become so good out of the box that it’s usually completely acceptable to give general tasks to them without modification. Meanwhile, more specific tasks that you want to be repeatable can have skills made for them. To me, this leaves little use case for making specific agents, though skills are still relatively new and I’m happy to hear about other use cases for agents.

Troubleshooting – Help! My skill isn’t triggering!

Sometimes, a skill may not trigger when you expect it to. Since this comes down to relying on AI for when it’s appropriate to call a skill, and since AI is non-deterministic, it may still make mistakes like this.

When this has happened to me, I’ve told Copilot what was happening and asked it if I should make any changes to the skill’s name and description to make it more clear when to run it. This has helped, although there’s no silver bullet here. You may have to finagle a bit to land on something consistent if you’re having issues.

Skill examples & resources

• https://github.com/github/awesome-copilot/tree/main/skills
• https://github.com/anthropics/skills

Github example

You can find a full working example of this at the following Github repository: https://github.com/danielwarddev/CopilotSkillsExample