In October 2025, Anthropic announced Agent Skills. As Agents become more powerfull, the wanted a more composable, scalable, and portable way to equip these agent with domain specific expertise.
This led them to create Agent Skills: organized folders of instructions, scripts, and resources that agents can discover and load dynamically to perform better at specific tasks.
Building a skill for an agent is like putting together an onboarding guide for a new hire. Instead of building fragmented, custom-designed agents for each use case, anyone can now specialize their agents with composable capabilities by capturing and sharing their procedural knowledge.
Skills are folders of instructions, scripts, and resources that agents can discover and use to perform better at specific tasks. Write once, use everywhere.
They work across Copilot coding agent, Copilot CLI, and agent mode in Visual Studio Code Insiders. Skills support is coming to the stable version of VS Code in early January 2026.
When Copilot determines a skill is relevant to your task, it loads the instructions and follows them—including any resources you’ve included in the skill directory.
You can write your own skills, or use skills shared by others, such as those in the anthropics/skills repository or GitHub’s community created github/awesome-copilot collection.
To add skills to your repository and start using them with GitHub Copilot, follow these steps:
First, create a .github/skills directory in your repository to store your skills.
Note: Skills stored in the .claude/skills directory are also supported.
Each skill should have its own directory within .github/skills. For example:
.github/skills/webapp-testing.github/skills/github-actions-failure-debuggingSkill directory names should be:
name in the SKILL.md frontmatterEach skill directory must contain a SKILL.md file (the name must be exactly SKILL.md).
The SKILL.md file is a Markdown file with YAML frontmatter that includes:
Required fields:
name: A unique identifier for the skill (lowercase, using hyphens for spaces)description: A description of what the skill does and when Copilot should use itOptional field:
license: A description of the license that applies to this skillThe Markdown body should contain the instructions, examples, and guidelines for Copilot to follow.
You can optionally add scripts, examples, or other resources to your skill’s directory. For example, if you’re creating a skill for image conversion, you might include a script for converting SVG images to PNG.
Here’s a practical example of a skill for setting up Python projects on Windows 11 using uv. This skill includes helper scripts and ensures every Python project follows the same best practices:
Skill Directory Structure:
.github/skills/python-project-setup/
├── SKILL.md
└── scripts/
├── setup_project.ps1
├── check_uv.py
└── create_pyproject.py
Complete example available at: stefanstranger/agentinstructions/python-project-setup
Location: .github/skills/python-project-setup/SKILL.md
---
name: python-project-setup
description: Sets up a new Python project with uv, virtual environment, and best practices for Windows 11. Use this when creating a new Python project or helping users set up their Python development environment with modern tooling.
---
## Python Project Setup with uv for Windows 11
When setting up a new Python project, use `uv` for fast, reliable package management. This skill includes helper scripts in the `scripts/` directory.
### 1. Check and Install uv
Use the provided script to check if uv is installed:
```powershell
# Check if uv is installed, install if missing
python scripts/check_uv.py
```
Or manually:
```powershell
# Install uv using pip
pip install uv
```
### 2. Quick Setup with Script
For a complete automated setup:
```powershell
# Run the setup script with project name
.\scripts\setup_project.ps1 -ProjectName "my-new-project"
```
### 3. Manual Setup Steps
#### Create Virtual Environment with uv
```powershell
# uv creates and manages virtual environments automatically
uv venv
```
#### Activate Virtual Environment
```powershell
# PowerShell activation
.\.venv\Scripts\Activate.ps1
```
If you get an execution policy error, run:
```powershell
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
```
#### Create pyproject.toml
Use the template script or create manually:
```powershell
# Generate pyproject.toml from template
python scripts/create_pyproject.py --name "your-project-name" --python-version "3.10"
```
Or manually create with this structure:
```toml
[project]
name = "your-project-name"
version = "0.1.0"
requires-python = ">=3.10"
dependencies = []
[project.optional-dependencies]
dev = [
"pytest>=7.0.0",
"black>=23.0.0",
"ruff>=0.1.0",
]
```
#### Install Dependencies with uv
```powershell
# Install project dependencies (much faster than pip)
uv pip install -e ".[dev]"
```
### 4. Project Structure
The scripts will create this structure:
```
project-name/
├── .venv/ # Virtual environment (don't commit)
├── src/ # Source code
│ └── __init__.py
├── tests/ # Test files
│ └── __init__.py
├── .gitignore # Includes .venv, __pycache__, *.pyc
├── README.md # Project documentation
└── pyproject.toml # Modern Python project file
```
### 5. .gitignore Configuration
Always exclude:
```
.venv/
__pycache__/
*.pyc
*.pyo
.pytest_cache/
.ruff_cache/
dist/
build/
*.egg-info/
The complete example skill is available in the python-project-setup repository.
Checks if uv is installed and installs it if missing.
Complete project setup automation:
Generates a pyproject.toml file with common configurations.
uv is 10-100x faster than pip for package installationpyproject.toml instead of legacy requirements.txtWhy This Skill is Valuable:
Instead of manually explaining these steps every time someone asks “How do I set up a Python project?”, Copilot will automatically follow this skill and can even use the helper scripts. This means:
uv installs packages 10-100x faster than pippyproject.toml (the new Python standard) instead of requirements.txtWhen performing tasks, Copilot will automatically decide when to use your skills based on:
When Copilot chooses to use a skill:
SKILL.md file is injected into the agent’s contextTo use the Python project setup skill in your repository:
Create the directory structure in your repository:
your-repo/
└── .github/
└── skills/
└── python-project-setup/
├── SKILL.md
└── scripts/
├── check_uv.py
├── setup_project.ps1
└── create_pyproject.py
Copy the files from the example repository into your .github/skills/python-project-setup/ directory.
Once the skill is added to your repository, Copilot will automatically use it when you ask questions like:
Direct Setup Requests:
Configuration Questions:
Tool-Specific Requests:
Troubleshooting:
Copilot evaluates the skill’s description:
“Sets up a new Python project with uv, virtual environment, and best practices for Windows 11. Use this when creating a new Python project or helping users set up their Python development environment with modern tooling.”
When your prompt matches these keywords or concepts:
Copilot will load the skill and follow the instructions in SKILL.md, including referencing the helper scripts.
setup_project.ps1 or check_uv.pyThis means you get consistent, repeatable results every time someone in your team asks about Python project setup.
Agent Skills work with:
Note: Currently, skills can only be created at the repository level. Support for organization-level and enterprise-level skills is coming soon.
You can use both skills and custom instructions to teach Copilot how to work in your repository:
You can write your own skills or use skills shared by others: