Summary of "Что такое Skills?!"

High-level summary

“Skills” are an open-standard packaging and metadata format for tooling and documentation that coding agents (e.g., Claude/Cloudcode, Cursor, Codex) can discover and load at runtime.
Purpose: reduce context/token bloat and improve agent performance by keeping only short announcements in the main context and loading full skill contents (docs, scripts, binaries) only when the agent judges the skill relevant.
Origin: evolved from earlier mechanisms (for example, Cursor’s conditional rules) created to save tokens and load large docs/tools only when necessary.
The spec recently became an open standard and is now widely supported across major coding agents.

Technical details and structure

A skill is a folder containing a small, defined set of files:

skill.md (required)
- Uses front-matter at the top (fields between hyphens).
- The front-matter description field is the short announcement that always sits in the agent’s context (commonly limited to ~1024 characters).
reference.md (optional)
- Holds more detailed technical documentation and examples.
scripts/ (per spec)
- Executable scripts the agent can run (bash, Python wrappers, compiled binaries, etc.).
Other supporting files
- Binaries, helper docs, or assets that the agent may optionally fetch when loading the skill.

Loading behavior

At session start, agents keep only the short description (front-matter) in context.
When the agent judges a skill relevant (based on that short description), it loads the full skill.md and may fetch referenced files and scripts.
Agents then execute scripts or use the additional documentation as needed.

Note: this is a thin abstraction over documentation + tools rather than a fundamentally new capability — the key value is on-demand loading to save tokens and improve efficiency.

Benefits and use cases

Token savings: avoids injecting long tool descriptions into every session and eliminates large initial token costs when many tools or MCPs are present.
Efficiency with subagents: each subagent can selectively load only the skills it needs (for example, a planner loads a doc-reading skill while an implementer loads a GitHub MR skill), preventing exponential context duplication across subagents.
Faster runtime and reduced cache/warm-up overhead on large contexts.

Practical guidance, gotchas, and best practices

Do not expose credentials in the skill description/front-matter — keep secrets out of the announcement.
Place executables in a scripts/ directory per the standard (avoid placing them at the repo root).
For language runtimes such as Python, wrap interpreter scripts in a bash wrapper that:
- Bootstraps a virtual environment and installs dependencies on first run.
- Then runs the actual interpreter script (this avoids environment issues).
Keep reference.md for code examples and technical detail; keep skill.md’s description concise.
Agents should ask permission or at least indicate they will use a skill before loading it (the demo showed Cloudcode asking to activate the skill).
Skill location: the skill.md location defines the skill root, so a skill may live in any project folder — a convenience that also raises security concerns (malicious packages could include a skill.md).

Demo / tutorial summary

The video series uses a two-part approach:

Part 1: Theory and overview of the skill specification (concepts, format, and benefits).
Part 2: Hands-on tutorial (creating a skill with Cloudcode and manually).

Hands-on highlights:

Used Cloudcode’s built-in subagent to fetch docs and scaffold a skill that runs test MySQL queries.
Edited the scaffold:
- Removed credentials from skill.md.
- Moved/created scripts into scripts/.
- Added a bash wrapper around the Python script to ensure proper venv handling.
Tested behavior:
- Ran unrelated tasks — the skill did not load.
- Issued a database-query task — the agent asked to activate the skill, loaded it, ran the script, and returned results.
Also created a minimal, manually authored “test” skill (skill.md) to show that agents will load hand-crafted skills the same way.

Outcome: Skills are simple to author (either auto-generated by tools like Cloudcode or hand-crafted), and agents respect the load-on-demand behavior.

Open issues and recommendations

Security
- Skill discovery and automatic loading (skills can be placed in any folder) introduce risks.
- Further security guidance is needed: trust policies, signing, install-time vetting, and other mitigations should be established.
Tooling and hygiene
- Prefer placing scripts in scripts/.
- Avoid leaking credentials in front-matter.
- Use wrappers to handle runtime/environment setup reliably.

What the video provides

A conceptual overview and a practical demo: Cloudcode scaffold → edit → test → manual creation.
A checklist of implementation tips and pitfalls from the hands-on workflow.
A promised follow-up video that will cover publishing skills and more detailed creation steps.

Main speakers and referenced platforms

Presenter: single narrator who authored the walkthrough (the demo’s primary speaker).
Mentioned platforms and tools:
- Anthropic (Claude / Claude Code / Cloudcode)
- Cursor
- Codex
- GitHub (cited as an example of many tool descriptions)
- Cloudcode’s built-in subagent (used in the demo)