One SKILL.md, three platforms

The most valuable part of an agent is not the model. You swap models in a dropdown. It is not the connectors either, those come off the shelf. What is valuable is the instruction: the hard-won knowledge of how a particular task is done correctly in your organisation.

And that was locked inside whichever platform you wrote it in. This is changing.

What is in a SKILL.md

A skill in Copilot Studio is a file. It has YAML front matter with a name and a description, and the instruction in Markdown underneath. That is it.

---
name: Supplier check
description: >-
Checks a new supplier against the internal approved list, assesses
the submitted evidence and produces an approval recommendation.
Use when a contract or a supplier request needs to be reviewed.
---

# Supplier check

## Procedure

1. Determine company name, legal form and registered office from
the documents.
2. Check the sanctions_list tool for matches. On a match, abort
immediately and escalate, do not produce an assessment.
3. Check whether the following evidence is present: trade
registration, proof of liability insurance, tax clearance
certificate.
4. If a document is missing, list it rather than estimating it.

## Output format

A table of evidence, status and where it was found. Below it exactly
one sentence of recommendation: approve, request more, or reject.

## Limits

You do not make a legal assessment. When in doubt, the recommendation
is always "request more".

A skill package is a ZIP file with this SKILL.md and optional companion files: scripts, templates, reference documents. You can write the skill in Copilot Studio or in your editor and upload it.

Why the format matters more than it looks

The decisive mechanism sits in the description in the front matter. The runtime only loads a skill when the request matches it. Before that it is not in the context.

That solves a problem large agents choke on regularly. When everything an agent should be able to do goes into the system instruction, the instruction eventually gets so long that the model overlooks the important parts. I have seen instructions that had grown to three screens because every new requirement was appended as another paragraph. The result is an agent that half-does twenty things.

With skills, the system instruction stays what it should be: role, tone, limits. Everything task-specific lives in modules loaded as the situation requires.

The practical consequence: the description is the most important line in the file. It is not a comment, it is the interface. An imprecise description means the skill never gets pulled, or gets pulled constantly, and both are hard to debug because the fault is not in the logic but in a sentence of prose.

The part that actually interests me

The format is not Microsoft-specific. Skills written for GitHub Copilot or for Claude Code can be imported into Copilot Studio without rewriting.

That is new and it is more than a convenience.

Until now, every investment in agent instructions was platform-bound. Prompt libraries, topic trees, instruction sets: all proprietary, all lost when the platform decision gets reversed. Swap Copilot Studio for something else and you started from zero.

A SKILL.md is a text file. It sits in git, it gets reviewed in a pull request, it has a history, and it runs in multiple runtimes. For the first time the most expensive part of agent work is an artefact that belongs to you, rather than a state in somebody else's database.

For me as DIE TECHNIKERIN this is the real advance of the year. Not a better model. A portable format for what we know about our own processes.

Where skills belong

My recommendation, and it is a clear one: not in the platform, in the repository.

A skill has every property of code. It gets versioned, it gets reviewed, it has regressions, it needs tests. If it only exists in the Copilot Studio designer, you have none of those properties. You have whatever state somebody last changed, with nobody knowing what was there before.

A workable setup looks like this:

• A skills/ directory in the repository, one subfolder per skill with a SKILL.md and companion files.
• Changes go through pull requests. The review examines the description as strictly as the instruction, because routing depends on it.
• One test case per skill in the agent's evaluation. Copilot Studio has had GA tooling for this since March, including multi-turn tests. A skill without a test case is a guess.
• Uploading to the platform is a deployment step, not the source of truth.

This is the same path infrastructure as code walked ten years ago. First you click it together, then you notice nobody remembers why something is set the way it is, then you write it down.

Where I am cautious

Portable does not mean identical. The same SKILL.md in two runtimes does not give you identical behaviour. The orchestrator decides when to load a skill, and that decision comes out differently on every platform, differently with every model, and differently again with every model version. The format is portable, the result is not. Using the same instruction across platform boundaries means you need evaluations on each side.

A concrete point on top: in Copilot Studio, skills hang off the GitHub Copilot harness, and that bills through Copilot Credits from the moment you build. Trying out skill variants is no longer a free afternoon project.

And one note that gets lost in the enthusiasm: a skill is an instruction, not a safeguard. What an agent must not do belongs not only in a Markdown file but in permissions, in DLP policies and in the identity it travels under. Instructions are followed with a certain probability. Permissions are not.

The short version

Skills are the first building block of the agent era that feels like proper software: a file, a format, a review, a history. Treat them accordingly and your work survives the next platform decision.

Treat them as clicking in the designer and it will not.

Sources

• Skills overview for agents, Microsoft Learn, as of 3 August 2026
• Choose a harness, Microsoft Learn, as of 3 August 2026
• What's new in Copilot Studio, Microsoft Learn
• Copilot Studio's New Harness, Power Plat Stack, August 2026, on importing skills from GitHub Copilot and Claude Code