Introduction

I have been trying to get my head around Agent Skills in VS Code. Agent Skills let you provide specialised knowledge and capabilities tailored to specific workflows. Rather than repeatedly explaining how I want deployments handled or how to debug a particular setup, I encode that knowledge once in a skill and Copilot can then apply it consistently when using the skill.

Skills work in VS Code, GitHub Copilot CLI, and the Copilot coding agent. They are portable, reusable, and based on an open standard, so skills I create can be shared across an organisation or the broader developer community.

For background on related Copilot features, see Adding Custom Agents to GitHub and Understanding MCP Servers (Part 1).

What Are Agent Skills?

Agent Skills are folders containing instructions, scripts, resources, and examples that teach Copilot how to perform specialised tasks. Each skill is a self-contained unit of knowledge about a specific workflow, tool, or process.

Think of skills as plugins for Copilot. When Copilot is asked to perform a task, it checks available skills and loads the relevant one. The skill provides instructions, examples, and context that guide Copilot’s behaviour.

Key characteristics:

• Modular: each skill lives in its own directory with a SKILL.md file
• Context-aware: loaded only when relevant to the current task
• Portable: based on an open standard, skills work across different Copilot interfaces
• Reusable: share skills within teams, organisations, or the community
• Executable: can include scripts and resources Copilot can use

Why Agent Skills Matter

Without skills, Copilot relies on its training data and general instructions. This works well for common tasks but falls short for:

• Domain-specific workflows (deployment processes, testing patterns, security requirements)
• Technology-specific conventions (Bicep modules, Kubernetes manifests, CI/CD pipelines)
• Team standards (code review checklists, documentation formats, naming conventions)
• Complex multi-step processes (incident response, release procedures, debugging workflows)

Agent Skills bridge this gap. Instead of repeatedly explaining conventions to Copilot, the conventions can be encoded once in a skill, and Copilot applies them consistently.

Where I have felt this most is debugging a failing GitHub Actions workflow. Without a skill, Copilot might suggest generic fixes that ignore the way I actually wire up my pipelines. With a skill, it walks the same checklist I would: list recent failures, pull the failed-step logs, look for the patterns I have documented, and propose a fix that fits my conventions. The cognitive load drops because I no longer have to re-explain context every session.

Agent Skills vs. Custom Instructions

GitHub Copilot supports both custom instructions and Agent Skills. Understanding the difference helps in choosing the right tool.

Custom instructions (.github/copilot-instructions.md):

• Always loaded and applied
• Best for general coding standards, conventions, and preferences
• Simpler, text-based format
• Examples: coding style, naming conventions, preferred libraries

Agent Skills (.github/skills/):

• Loaded on-demand when relevant
• Best for specialised workflows and multi-step processes
• Support scripts, resources, and complex instructions
• Examples: deployment procedures, testing workflows, debugging guides

Use custom instructions for information Copilot should always know:

- Use TypeScript strict mode
- Follow Microsoft TypeScript coding conventions
- Always include JSDoc comments for public APIs
- Prefer async/await over promise chains

Use Agent Skills for task-specific workflows:

- Debugging failed deployments
- Running security scans
- Creating release notes
- Migrating database schemas

Most projects benefit from both: custom instructions for general conventions, skills for specialised tasks.

Using Agent Skills in VS Code

Agent Skills are available in current VS Code builds with GitHub Copilot. The easiest way to inspect or create them is through the Agent Customizations editor.

Prerequisites:

• Visual Studio Code (latest version recommended)
• GitHub Copilot extension installed
• GitHub Copilot subscription that includes the workflow you want to use (for example, agent mode in VS Code, Copilot CLI, or the cloud agent)

Open and manage skills:

1. Open the Command Palette
2. Run Chat: Open Customizations
3. Open the Skills tab to create or manage workspace and user skills
4. Store project skills in .github/skills/, .claude/skills/, or .agents/skills/

Verify:

1. Open Copilot Chat
2. Type / to see available skills in the slash-command menu
3. Ask for a task that matches a skill description and watch Copilot load it automatically

Using Skills in VS Code

Once enabled, Copilot automatically loads relevant skills based on the prompt.

Example interaction:

You: "Deploy the storage account Bicep template to the dev environment"

Copilot: [Loading skill: bicep-deployment]
I'll help you deploy the storage account following our standard deployment process.

First, let's validate the template:

az bicep build --file infrastructure/storage/main.bicep
az deployment sub validate \
  --location eastus \
  --template-file infrastructure/storage/main.bicep \
  --parameters infrastructure/storage/dev.bicepparam

After validation succeeds, I'll run what-if analysis to show what changes will be made...

Copilot follows the workflow defined in the skill, applying my conventions automatically.

Manual skill selection:

A skill can be referenced explicitly:

You: "Use the bicep-deployment skill to deploy this template"

This forces Copilot to use a specific skill even if it might not have selected it automatically. I find this useful when two skills overlap and I want to be sure which one runs.

Agent Skills vs. MCP Servers vs. Custom Agents

Three Copilot features keep coming up in conversation and the lines between them are not always clear. A short comparison:

Agent Skills:

• Encode workflows and instructions
• Loaded on-demand when relevant
• Include scripts and examples
• Best for: repeatable processes, team conventions, specialised workflows

MCP servers:

• Connect Copilot to external data and systems
• Real-time data access and tool invocation
• Best for: querying databases, accessing APIs, integrating external services

See Understanding MCP Servers (Part 1) for more on MCP.

Custom agents:

• Specialised AI assistants for specific roles
• Defined at repository or organisation level
• Best for: role-based workflows (docs agent, security agent, DevOps agent)

See Adding Custom Agents to GitHub for details on custom agents.

The most effective workflows I have built use all three together. A DevOps agent picks up the role context, a deployment skill encodes the process, and an MCP server provides the live infrastructure data. Each layer does one job well, and the combination is far stronger than any single piece.

Key Takeaways

• Agent Skills are folders of instructions, scripts, and examples that Copilot loads on-demand
• They are portable across VS Code, the Copilot CLI, and the coding agent, and based on an open standard
• Custom instructions are always-on; skills are loaded only when relevant — use both, not one or the other
• Skills sit alongside MCP servers (data) and custom agents (roles) — each covers a different concern
• The biggest win for me has been consistent behaviour without re-explaining context every session

In the next post I cover how to actually build a skill, directory layout, the SKILL.md format, three worked examples, and the trade-offs I have run into so far.

Further Resources

Official documentation:

• VS Code Agent Skills Documentation
• GitHub Docs: About Agent Skills

Related posts:

• Understanding MCP Servers (Part 1)
• Understanding MCP Servers (Part 2)
• Adding Custom Agents to GitHub