Elegant

Agent skills are how you stop re-explaining yourself to the model

The Elegant team 5 min readai-and-frontend
Agent skills are how you stop re-explaining yourself to the model

If you have used an AI coding assistant for more than a week, you have felt this: you paste the same paragraph of context into every prompt. “Components go in ui/atoms, they take props and don’t fetch, use our design tokens not raw values, tests use Vitest…” Retyping that is the symptom; a skill is the cure. A skill is a packaged, reusable set of instructions the model loads for a class of task — so instead of re-explaining your conventions each time, you write them once, and the model picks them up whenever the task matches. It is the DRY principle applied to your own prompts: the moment you copy-paste guidance twice, you have found a skill waiting to be extracted.

Repeating context in every prompt versus loading one reusable skill Left: three prompts each re-pasting the same rules. Right: one skill file holding the rules, loaded by each task automatically. re-explain each time prompt 1 + rules (pasted)prompt 2 + rules (pasted)prompt 3 + rules (pasted) load a skill skill: the rules, once task loads ittask loads it
Re-pasting rules into every prompt is duplication; a skill holds the guidance once and every matching task loads it — DRY for prompts.

A skill is instructions plus the triggers that load it

Concretely, a skill is a document of instructions with metadata that says when it applies. The open Agent Skills format is a SKILL.md with front matter — a name, a description, and triggers — followed by the guidance itself:

---
name: author-atom
description: Build a presentational atom to our conventions.
triggers: [atom, button, input, presentational component]
---
Atoms live in src/ui/atoms/, take props, render only.
They must NOT fetch, import the store, or hold state.
Use design tokens (var(--space-md)), never raw values.

Now when a task mentions building an atom, this loads automatically, and you never retype the rules — the same way a function call beats copy-pasting a block of code.

The skill’s guidance is only as good as its eval

A skill can drift or be wrong, so the mature version pairs the instructions with an eval that checks whether output following the skill actually meets the standard. That turns “here are the rules” into “here are the rules, and here is how we verify they were followed”:

// the skill's eval — does an atom built under it obey the boundary?
test("author-atom output is a pure atom", () => {
  const src = read(generatedPath);
  expect(src).not.toMatch(/useSelector|fetch\(|useState/);   // the skill's rules, checked
  expect(src).not.toMatch(/#[0-9a-f]{3,6}/i);                // tokens, not raw colours
});

Skills are how team knowledge scales past one head

The deeper value shows up on a team. Conventions that live in a senior engineer’s head get applied when that person reviews; the same conventions written as a skill get applied on every task by everyone, including the AI. A skill is encoded expertise — the same move as turning a review comment into a lint rule, but for the generative side: instead of catching violations after the fact, you supply the standard up front so the model produces conforming output in the first place. Extract a skill the moment you paste the same context twice, give it an eval so its guidance stays honest, and your accumulated conventions become reusable leverage rather than a paragraph you retype forever. The harness-skill-eval exercise builds exactly the eval half — the check that keeps a skill’s instructions from silently going stale.