# Turn what you know into a skill

> How to turn your own notes, or the public work of people you trust, into a skill your agent reads, laid out so it loads at the right moment and stays small until it's needed, plus a design memory it reads before it starts.

Module: Working with AI · Level: intermediate · 9 min · https://school.agents.org.in/foundations/working/knowledge-into-skills

You ask an agent how to write an error message, and it gives you a confident answer from nowhere in particular. It sounds fine. But you know three people whose advice on error messages you'd actually trust, and this isn't quite what any of them would say. What if the agent answered from them instead?

## A skill pins the source

A skill (A folder of written instructions an agent loads when a task matches, so it does the work the way you want instead of its default way) is a folder of plain notes written for your agent. When a request matches what the skill is about, the agent opens it and leans on what's inside rather than on the average of everything it read during training.

That's the useful part: you choose what goes in. A skill can hold your team's hard-won rules, or the ideas of people you've decided to learn from. Either way, it pins the source, so the answers stop coming from nowhere in particular.

## From your own notes

Start with what you already know. Dump it into one messy note: rules you follow, mistakes you've seen, the reasons behind your choices. Then ask the agent to turn it into a draft skill. Agents write well for other agents, so the first draft is usually decent.

Then prune it, because the draft will be soft. Hedges become numbers ("reasonably short" becomes "under 300ms"). Every rule gets a one-line reason, so the agent can apply it to cases you didn't list. And anything the agent already knows gets deleted, because it only adds noise.

*[Interactive demo: Tap each draft line to rewrite it the way a skill needs it.]*

## From someone's public work

You can do the same with the public work of a person or team you trust: Apple's design talks from WWDC with their published transcripts, an essayist's website, a library's documentation. A skill built this way, with every claim linked to where it came from, is a brain skill (A skill built from a person's or team's public work, with every claim linked to its source, so the agent answers from what they actually said. Use it to review your work, not to pass yours off as theirs). The agent answers from what they actually said, and you can check it.

  **Step: Collect the sources.** Gather the talks, essays or docs. Keep the raw copies in a research folder outside the skill, so the skill stays small.

  **Step: Pull out the claims.** Ask the agent for the concrete claims, each with a link and a timestamp or page. A claim you can't trace doesn't go in.

  **Step: Group them into theme files.** Motion in one file, typography in another, feedback in a third. Each theme file is something the agent opens only when that theme comes up.

  **Step: Write SKILL.md last.** A short description, their core ideas and method in a few lines, and a pointer to each theme file.

> **The honesty rules.** Public material only, never paid or private content. Credit the source inside the skill and in anything you publish with its help. Use it as a reviewer or a consultant ("what would this argue about my onboarding?"), never to pass writing off as theirs. Keep every claim cited so you can check it. The design-engineering skill this school is built on credits Emil Kowalski, Benji Taylor, Jakub Krehel and others in exactly this way.

**Build a skill from public talks (paste into your agent):**

```text
Build a skill from Apple's public WWDC sessions on interface design (use the published transcripts).
Keep the raw transcripts in /research/wwdc, outside the skill folder.
Pull out the concrete claims, each with the session name and timestamp, and group them into theme files (motion, materials, typography, feedback).
Write SKILL.md last: a short description with trigger words, the core ideas, and a link to each theme file.
Credit Apple and every session in the skill. Show me the description before you write anything else.
```

A few of these make a quiet fleet of reviewers: one for product questions, one for launch copy, one for type. You stay the author. Each skill checks your draft against ideas you once agreed with, and tells you what you missed.

## Lay it out so it loads right

How a skill is laid out decides when it loads and how much it costs. There are three layers.

The skill description (The short text at the top of a skill that says when to use it. Your agent reads every installed skill's description all the time and loads a skill only when your request matches it) is the short text at the top that says when to use the skill. Your agent sees every installed skill's description all the time, so it should name the moment and a few trigger words ("use when writing error messages or empty states"). `SKILL.md` opens when the description matches, and it should stay short, a table of contents. Big areas live in their own reference files (An extra file inside a skill folder that the agent opens only when a job needs it. It lets a skill hold a lot of detail without filling the agent's attention), extra files the agent opens only when that area is in play. **Depth then costs nothing until it's used.**

*[Interactive demo: Pick a request. Only the layers it needs open, and the rest stay closed.]*

Some skills should never start on their own: one that questions you about ideas, or one written in a particular person's voice. Make those a user-invoked skill (A skill that only runs when you call it by name, never on its own. Set with disable-model-invocation: true, it suits skills that question you or answer in someone's voice), one that only runs when you call it by name, by adding `disable-model-invocation: true` to its frontmatter.

## Check it loads

Write ten prompts that should load the skill and ten that shouldn't, and try them on more than one model, because a skill that loads perfectly on one model can sit ignored on another. When the agent gets something wrong despite the skill, add one dated line to a gotchas (One dated line in gotchas.md recording something the agent got wrong in practice, and the fix. The file only grows, and negative examples teach the agent the most) file with the fix. That file only grows, and it ends up teaching the most.

## A design memory it reads first

Skills hold rules that travel between projects. Your product also needs somewhere to keep what's true about it: the references you chose, decisions and their reasons, critiques you've already had. Without that, the agent starts every session fresh and cheerfully proposes the blue you rejected two weeks ago.

Andrej Karpathy's public LLM Wiki idea is a good model for this. Instead of making the agent search raw files every time, you let it keep a small, linked set of markdown notes up to date: an index with a line per note, and a log it appends to. Applied to design, that's a design memory (A small, growing folder of notes about your product's design (references, decisions and their reasons, past mistakes) that your agent reads before it starts, so it remembers what you've already settled), a folder the agent reads before it works and adds to when you settle something.

```
design-memory/
  index.md        ← one line per note: what it is, when it matters
  log.md          ← dated, append-only: "2026-10-20 accent stays green, blue tested worse"
  references/     ← the screens and sites you're aiming at, with why
  decisions/      ← one note per settled question
```

*(Ask the agent to tidy it now and then: contradictions, stale decisions, notes nothing links to.)*

## What to remember

- A skill pins the source: draft it from your notes or from public work, then prune hedges into numbers and give every rule a reason.
- Keep it in layers: a description with trigger words, a short SKILL.md, and reference files that open only when needed. Skills that question you only run when called.
- Give each product a design memory, an index and a decision log the agent reads before it starts.

**Check yourself:** Your 'ask me questions about the idea' skill keeps starting by itself while you code. What fixes it?

- [x] Add disable-model-invocation: true to its frontmatter
- [ ] Make the description longer
- [ ] Merge it into another skill
- [ ] Delete the body

*Why:* That flag makes it a user-invoked skill: the agent no longer loads it by matching your words, so it only runs when you call it.

Go deeper: [Make it yours](/learn/agents/make-it-yours) · [What is a skill?](/learn/start/what-is-a-skill)

## In the skill

- https://school.agents.org.in/skill/meta/skill-writing-rules.md
- https://school.agents.org.in/skill/meta/cross-model-testing.md
- https://school.agents.org.in/skill/meta/gotchas.md