Nový standard Agent Skills pro vaše kódovací pracanty v GitHub Copilot

Příliš mnoho kontextu agentovi často nepomůže. Naopak mu zhorší rozhodování, zvýší latenci a u některých nástrojů i cenu. U GitHub Copilot to platíte spíš ve formě Premium Requests, takže to nemusíte počítat po tokenech tak úzkostlivě, ale princip je stejný: co není relevantní pro aktuální úlohu, nemá modelu zbytečně překážet.

Finta Skills je v tom, že se do kontextu dostane jen seznam skillů: název, popis a cesta k detailním instrukcím. Agent tak ví, že skill existuje, ale jeho plný obsah si přečte až ve chvíli, kdy podle popisu usoudí, že ho potřebuje.

Struktura adresáře je předepsaná. Musí obsahovat SKILL.md s YAML hlavičkou, názvem a popisem. V těle pak mohou být instrukce, postupy, odkazy na další soubory a popis skriptů, které má agent umět používat.

Typická místa v repozitáři:

• .github/skills/jmenoskillu
• .claude/skills/jmenoskillu

Do stejného adresáře můžete přidat třeba scripts/, references/ nebo README.md. Důležité je, aby SKILL.md agentovi řekl, co v nich najde a kdy to má použít.

Začněme jednoduchým příkladem. Tohle je celý SKILL.md:

.github/skills/simplecontext/SKILL.md

---
name: simplecontext
description: This contains information about company project code-named BigDog
---

Here are information about this project:
- Owner: Michael Coder
- Inventary number: 54321

Využijeme toho, že ve VS Code umíme zobrazit, co se skutečně posílá do modelu: Chat Debug view nebo log requestů. Nejdřív se jen zeptám na Ping.

V requestu je toho hodně: metadata nástrojů, system prompt, instrukce agenta a další pracovní kontext. Zkráceně například definice nástroje apply_patch:

Ukázka metadat nástrojů ve zkrácené podobě

[
  {
    "function": {
      "name": "apply_patch",
      "description": "Edit text files...",
      "parameters": {
        "type": "object",
        "properties": {
          "input": { "type": "string" },
          "explanation": { "type": "string" }
        },
        "required": ["input", "explanation"]
      }
    },
    "type": "function"
  }
]

Pak následuje zabudovaný system prompt. Opět jen krátký výsek:

Výsek system promptu

You are an expert AI programming assistant, working with a user in the VS Code editor.
Your name is GitHub Copilot.
<coding_agent_instructions>
You are a coding agent running in VS Code. You are expected to be precise, safe, and helpful.
</coding_agent_instructions>

A pak přijde sekce Skills. Tady je jádro celé věci:

Seznam skillů v kontextu

<skills>
Here is a list of skills that contain domain specific knowledge on a variety of topics.
<skill>
<name>simplecontext</name>
<description>This contains information about company project code-named BigDog</description>
<file>c:\git\gh-copilot-demo\.github\skills\simplecontext\SKILL.md</file>
</skill>
</skills>

V kontextu je tedy pouze název, popis a cesta. Není tam vlastník projektu ani inventární číslo. Na dotaz Ping model skill nepotřeboval, takže odpověděl obyčejně:

Odpověď bez načtení skillu

pong — I'm here and ready. What would you like me to do next?

A teď to přijde. Zeptám se:

Dotaz, který vyžaduje detail skillu

What is inventory number for BigDog

Tahle informace není v kontextu, není v názvu skillu a není ani v jeho popisu. Model ale z popisu pochopí, že by měl načíst soubor SKILL.md.

Po načtení už ví odpověď:

Tohle je přesně ten rozdíl proti tomu, když všechno nacpete do AGENTS.md. Detailní informace existuje v repozitáři, ale model ji čte až v okamžiku, kdy je relevantní.

Skills nejsou jen na textový kontext. Dobře se hodí i na vysvětlení, jak má agent používat připravený skript. Tady je zkrácený SKILL.md pro konverzi JSON na XML:

.github/skills/json-to-xml-converter/SKILL.md

---
name: json-to-xml-converter
description: Convert JSON data to XML format with customizable root element and attribute handling
---

# JSON to XML Converter Skill

## Purpose

Convert JSON data structures into well-formed XML documents.

## Usage

~~~bash
python .github/skills/json-to-xml-converter/scripts/json2xml.py input.json output.xml
python .github/skills/json-to-xml-converter/scripts/json2xml.py input.json output.xml --root "data"
echo '{"name": "test"}' | python .github/skills/json-to-xml-converter/scripts/json2xml.py - -
~~~

## Parameters

- `input_file`: Path to JSON file or `-` for stdin
- `output_file`: Path to XML output file or `-` for stdout
- `--root`: Root element name, defaultně `root`

Pointa není v tom, že JSON na XML je světoborný problém. Pointa je v kontraktu: agent se z popisu skillu dozví, že existuje hotový skript, a z detailu skillu zjistí, jak ho správně spustit.

V adresáři scripts je kromě dokumentace i samotný kód. Zkráceně vypadá takhle:

scripts/json2xml.py

#!/usr/bin/env python3

import argparse
import json
import sys
import xml.etree.ElementTree as ET
from typing import Any, Optional

def sanitize_tag_name(name: str) -> str:
    sanitized = name.replace(" ", "_")
    sanitized = "".join(c if c.isalnum() or c in ("_", "-", ".") else "_" for c in sanitized)
    if sanitized and sanitized[0].isdigit():
        sanitized = "_" + sanitized
    return sanitized or "item"

def dict_to_xml(data: Any, parent: Optional[ET.Element] = None, tag_name: str = "item") -> ET.Element:
    element = ET.Element(sanitize_tag_name(tag_name)) if parent is None else ET.SubElement(parent, sanitize_tag_name(tag_name))
    if isinstance(data, dict):
        for key, value in data.items():
            dict_to_xml(value, element, key)
    elif isinstance(data, list):
        for item in data:
            dict_to_xml(item, element, "item")
    elif data is None:
        element.text = ""
    else:
        element.text = str(data)
    return element

def convert_json_to_xml(json_str: str, root_name: str = "root") -> str:
    data = json.loads(json_str)
    root = dict_to_xml(data, tag_name=root_name)
    return ET.tostring(root, encoding="utf-8", xml_declaration=True).decode("utf-8")

V plné verzi je ještě CLI parsing, hezčí výpis chyb a zápis do souboru nebo na stdout. Pro agenta je ale nejdůležitější to, že nemusí vymýšlet konverzi sám. Má použít připravený nástroj.

Teď vezmu JSON soubor, přihodím ho do chatu jako kontext a řeknu:

Prompt

convert this to xml

Agent správně vyhodnotí, že má použít skill, načte si instrukce a spustí skript. Výborný výsledek.

Tady je ještě pohled na debug log:

Pár dalších příkladů najdete na GitHubu Anthropicu.

Pozor při stahování skills z internetu. Často obsahují skripty a ty se pak spouští lokálně pod právy vašeho uživatele.

Za mě se z toho skládá docela praktické pravidlo:

Skills standardizují něco, co šlo ručně udělat už dřív: v AGENTS.md byste mohli vést seznam dalších souborů a říkat agentovi, kdy je má číst. Jenže to je práce navíc, snadno vznikne nekonzistence a hůř se to přenáší mezi projekty.

Proto čekám, že se Skills stanou běžnou součástí tuningu jednotlivých modelů. Protože s tím přišel Anthropic, dá se očekávat, že Claude modely na tento vzor budou dobře připravené; u OpenAI Codex a Google bych čekal totéž. Nejde jen o standardizaci souborů, ale i o to, že LLM bude na ten způsob práce specificky trénované a bude ho používat spolehlivěji.