Skip to main content
Picture a shelf of instruction cards. Each card holds the steps for one kind of job. When that job comes up, the loop reaches for the right card.
The image shows a sequence of workflow steps: "Deploy App," "Run Tests," "Backup Data," and "Notify Team," each with corresponding icons and numbered lists. It illustrates a process initiated by a job event.
Those cards are called skills. A skill is packaged know-how the agent loads only when it needs it. In practice a skill is a short file named skill.md that tells the loop exactly when and how to perform a particular task.
A skill is not a long manual — it’s a compact recipe. Keep skills focused so the loop can load and execute them quickly.

​
What goes in a skill.md

A skill.md file has three simple parts: A minimal skill.md might look like this:
The description is especially important: it acts like a label that says, “use me for this kind of task.” The loop watches the current task and loads a skill only when that description matches the job. If a job needs more than one skill,
The image is a diagram showing a flow related to skill tasks, specifically about writing a commit message, with three files: "build-app.md," "commit-helper.md," and "run-tests.md." It highlights that only the skill with a matching description loads.
several skills can load at once. As the task changes, different pieces of know-how appear at the right moment. Skills can also reference helper scripts, API cheat sheets, sample commands, or other artifacts that the skill.md file points to.

​
Why not one giant prompt?

Two practical reasons favor small, focused skills over a single monolithic prompt:
  • Consistency: The same skill provides the same steps every time, which prevents the agent’s behavior from drifting.
  • Clarity: Smaller skills keep the prompt tidy. Instead of a huge wall of instructions, the loop maintains a concise prompt and pulls in only the know-how it needs. Less clutter means clearer thinking and fewer mistakes.
The image illustrates the concept of a consistent skill loop, showing that a specific skill involves performing the same steps in every run.

​
Golden rule: process over prose

A good skill is a short list of concrete steps with a clear finish. Avoid long essays inside skills — an agent might read and move on, but it will follow and verify a step-by-step sequence.
Write steps, not essays. Concrete, testable instructions let the loop execute and check outcomes reliably.
The image illustrates a comparison between a cluttered and a tidy prompt for writing commit messages, emphasizing that a cleaner prompt leads to clearer thinking and fewer mistakes.
Steps should be actionable and verifiable (for example: “run tests and fail if any test fails” or “produce a one-line summary”). That lets the loop detect completion and move to the next job or skill.

​
Examples of useful skills

Here are common skill types often found in automation loops:
  • Commit message authoring — short, consistent commit summaries and extended body guidelines.
  • Build and release steps — compile, package, and publish artifacts.
  • Test harnesses and honesty checks — run a test suite or graded harness that the agent does not own, then report pass/fail.
The image presents three skills with corresponding steps: writing clean commit messages, building a program, and staying honest with a test suite. Each skill is detailed through a list of specific actions to follow.

​
Benefits (at a glance)

​
Best practices

  • Keep each skill focused on one job or intent.
  • Make descriptions specific and short to improve match accuracy.
  • Write steps that are executable and testable.
  • Include references to helper scripts or API calls rather than embedding long examples in the skill itself.
To recap: a skill is packaged know-how in a short skill.md file containing a name, a description, and steps. Write skills as steps, not essays. Use the description to tell the agent when to load the skill. Skills keep the loop consistent and the prompt uncluttered. This article also discusses connectors and plug-ins, explaining how the loop integrates external services and tools.

Watch Video