Visual Studio 2026 Agent Skills: What Developers Get

Visual Studio 2026 May update shipped Agent Skills — a way to commit reusable Copilot instruction sets directly to your repository. Unlike custom instructions that apply to every conversation regardless of context, skills are task-specific: Copilot loads them only when the current task matches their trigger description. Less wasted context, more precise behavior. The spec behind them is open, cross-IDE, and already supported by VS Code, Claude Code, and the GitHub Copilot CLI — which means anything you build in your repo now works across tools.

Skills vs. Custom Instructions: Why the Difference Matters

Most developers using Copilot today have custom instructions set up — a markdown file defining coding conventions, preferred patterns, team standards. That works fine until your project grows. Custom instructions fire on every conversation. They burn tokens explaining your React conventions when you are actually working on the database migration layer. At scale, that is noise.

Agent Skills are the targeted answer. The model decides when a skill is relevant based on its description field and loads it only then. A db-migration-review skill activates when you are reviewing schema changes. A react-component skill activates when you are building UI. Neither fires when it is not needed. A monorepo team with React, .NET, and data science notebooks can maintain separate skills for each — clean, focused, no cross-contamination.

The practical upshot: stop pasting the same context paragraph into every Copilot session. Write it once as a skill, commit it to the repo, and every developer on the team gets consistent AI behavior automatically.

The SKILL.md Format

A skill is a directory containing at minimum a SKILL.md file. The format follows the open agentskills.io specification: YAML frontmatter followed by Markdown instructions.

skill-name/
├── SKILL.md          # Required: metadata + instructions
├── scripts/          # Optional: executable code
├── references/       # Optional: supporting documentation
└── assets/           # Optional: templates and resources

The frontmatter has two required fields: name (lowercase, hyphens, max 64 characters) and description. The description field is the most underappreciated part of this feature. Most developers write something like Helps with code review. The model uses description to decide when to activate the skill — write it like a trigger condition:

---
name: db-migration-review
description: Review database migrations for safety. Use when reviewing
  schema changes, AlterTable calls, AddColumn/DropColumn operations,
  or any file in the Migrations/ directory.
---

## Migration Safety Checklist

- Flag DROP COLUMN statements without a corresponding data backfill step
- Check AlterColumn calls that change nullability on tables over 100k rows
- Require a matching Down() rollback method for every Up() method
- Verify index creation uses CONCURRENTLY on production-scale tables

Skills load progressively. The name and description load at startup across all your skills. The full body loads only when the skill activates. Supporting files in scripts/, references/, and assets/ load only when explicitly referenced. Useful context on demand — not a firehose.

Where Skills Live — and Why It Is Broader Than Visual Studio

Skills are discovered from two types of locations:

• Repository-level (committed, shared with the team): .github/skills/, .claude/skills/, .agents/skills/
• Personal/global (your machine, across all projects): ~/.copilot/skills/, ~/.claude/skills/

The cross-IDE compatibility here is significant. The same .github/skills/ directory is read by Visual Studio, VS Code, Claude Code, and the GitHub Copilot CLI. This is an open standard maintained under the Linux Foundation Agentic AI Foundation, co-founded by Anthropic, Block, and OpenAI. Write skills for your repo once. Every developer using any supported tool benefits automatically.

The .NET team already published a skills package demonstrating the pattern at scale: install via /plugin marketplace add dotnet/skills and get diagnostics skills that can identify heap corruption in GC code — the kind of deep platform knowledge that previously lived only in senior engineers heads.

Creating Skills in Visual Studio

Visual Studio surfaces a guided creation flow: open Copilot Chat, click the tools icon at the bottom right, open the Skills panel, and click the plus button. The guided flow asks where to save the skill (global or solution-level) and what to name it, then generates a SKILL.md skeleton. You fill in the description and instructions.

The manual path is faster if you know what you want: create the directory, write the SKILL.md, validate with skills-ref validate ./your-skill. Either way, VS surfaces all discovered skills in a panel where you can search, edit, and jump to file locations without leaving the IDE. Agent Mode shows which skills were activated for a given task, so unexpected behavior is debuggable.

Skills, Custom Agents, and MCP: Three Distinct Layers

Agent Skills fit into a layered model alongside two other VS 2026 capabilities:

• Custom Instructions: always-on style and convention guidance
• Agent Skills: task-specific reusable workflows — this article
• Custom Agents (.agent.md, March VS 2026 update): define a Copilot persona with specific tools, model, and MCP connections

They complement each other. Custom instructions define how the agent codes by default. Skills give it specialized knowledge for specific tasks. Custom agents define who the agent is for a particular workflow. Used together, they let a team create an AI collaborator that understands their codebase actual customs — not just generic coding patterns.

The Institutional Knowledge Angle

Every engineering team carries tacit knowledge — unwritten rules about why migrations are done a certain way, how code reviews run, which patterns exist for historical reasons and should not be replicated. That knowledge lives in senior engineers heads and gets transmitted through review comments and onboarding conversations. It evaporates when those engineers leave.

Agent Skills give that knowledge a durable, machine-readable home. Not documentation no one reads. Not a Notion page that is six months stale. A SKILL.md in your repository, version-controlled, discoverable by every AI tool your team uses.

The description field in your skill is a contract: when you see this kind of task, apply this knowledge. Get the description right, keep the instructions focused, and your team AI behavior gets more consistent — and portable — with every new tool that adopts the agentskills.io standard.