A skill is a way to turn a repeatable procedure into a product. Technically it is a folder with a required SKILL.md file, whose header requires a name and a description, plus optional directories for scripts, reference material and supporting files. Cursor looks for them in several standard places, including compatible directories of other agent tools, and a nested project skill automatically gets the scope of its subdirectory. The point of the mechanism is not storing text but that the procedure loads when it is needed and takes up no room until it is.
The naive alternative is to explain the same sequence of actions anew in every conversation. It works but scales badly: the wording differs a little each time, steps get lost, and the result depends on how thoroughly you wrote the request today. This shows worst when work is handed over: what lives in your habit of typing a request does not travel to a colleague along with the repository. A skill fixes the order, and from then on the procedure runs identically, while its changes go through ordinary review like code.
Progressive loading is the main engineering idea here. In the initial context only the skill's name and description are visible; the full content is pulled in on activation, and heavy material - references, templates, scripts - only when it is actually reached. That is why the main file is kept short: the trigger, the prerequisites, ordered steps, stop conditions and the required evidence. Everything bulky moves into separate directories. The saving is not decorative: a dozen skills each loading in full would eat the context before the work even starts.
It helps to see a skill's skeleton in full once. Below are a header with a name, a description and path patterns, and a body of four steps where the last step is an explicit stop before an action with external consequences. It is exactly the stop condition that separates an instruction skill from an automaton: the procedure brings the work to the point of decision and hands it to a human. Note the demand for evidence in the last item as well: without it a report turns into a claim that all is well, and there is nothing to check that claim against.
The description in the header carries more weight than it seems. The model uses it to decide whether the skill is relevant to the current task, so it must name the moment of application rather than an abstract capability. The wording validate a release candidate and produce a checklist works; the wording helps with releases does not. There is also the reverse case: if a skill should be started only by a human, automatic selection is disabled with an explicit field. That is done with procedures whose cost of a false trigger is higher than the benefit of switching on by itself.
It is worth drawing the boundary between a skill and a rule right away, because they get confused constantly. A rule describes an invariant that must hold at all times while you work with those files: it is short, it has no steps and it has no end. A skill describes a procedure with a beginning, an order and a finish: it switches on for an occasion and switches off once the work has reached its stop point. The requirement to return structured errors is a rule. The order of preparing a release is a skill. A requirement written into the wrong mechanism either hangs in the context uselessly or fails to switch on when needed.
Scripts inside a skill are a separate topic. They are convenient and at the same time widen the risk surface: it is executable code that will travel with the skill to whoever installs it and run with the process's rights. So a script is documented as a component - inputs, outputs, exit codes, behavior in negative cases - and reviewed more strictly than a text instruction. A skill without scripts remains a good default, and moving to a script is worth it when a step is genuinely deterministic and cheaper to run than to describe.
A bad skill is recognized by behavior rather than by its text. It either switches on where it is not wanted and gets in the way - usually because of an over-general description or over-wide path patterns; or it fails to switch on where it is wanted and has to be remembered by hand. The third sign is worse than both: the skill switches on, but its steps have drifted from reality because the project's check commands changed and the procedure did not. Hence simple hygiene: a skill that refers to the project's commands is updated in the same change that alters those commands.
The engineering conclusion is simple: a skill is a runbook, not an encyclopedia. A good skill fits on a screen and answers the question of how this is done here rather than retelling documentation. It is verifiable: it shows what must happen, where to stop and what evidence to attach. Such a skill outlives changes in the team; a long instructional text does not, because people stop reading it before it goes stale.
The typical failures are predictable. Writing a vague description and getting a skill that does not switch on when needed. Dumping everything into the main file and paying with context on every activation. Framing as a skill what is really a rule. Adding a script where an instruction would have been enough. And forgetting the stop condition - then the procedure walks up to an irreversible action on its own.
---
name: release-check
description: Validate a release candidate and produce a signed checklist.
paths:
- "apps/web/**"
---
# Release check
1. Read the canonical release runbook.
2. Run the existing lint, typecheck and focused tests.
3. Stop before publishing or changing production state.
4. Report the evidence and name the unresolved blockers.