It is a routine you have explained a dozen times — the exact same eight-step instruction, word for word, every single time. A procedure you re-type is a procedure you can save once and call by name.
Same routine, fifth time this week. The operator wants the AI to do one repeating job: pull the day's claims report, drop duplicates, keep only the open ones, sort by date, format a clean table, name the rooms. Eight steps. So he types all eight, in order, in plain English — the way you'd brief a new assistant. The AI does it perfectly. Tomorrow the same job comes up, and the brief is gone — a fresh chat remembers nothing — so he types the same eight steps again. And the day after that. Each time slightly differently, because he's typing from memory, so the output drifts a little each run. He is the only copy of the procedure, and he re-keys it by hand every time.
"I caught myself typing the same claims-report instruction for the fifth time in a week. Same steps, same order, every time slightly off because I'm doing it from memory. It hit me: I'm the manual. If I'm typing the identical thing this often, the computer should already know it. I shouldn't be the saved copy of my own routine."
"Honest version: every fresh chat I start blank — I don't remember yesterday's brief. So you re-narrating the eight steps isn't you being inefficient, it's the only way I'd know them. But that's a job for a saved file, not your fingers. Write the procedure down once as a named skill, and from then on one word loads all eight steps the same way every time. You stop being the human macro."
A skill (in Claude Code it shows up as a slash command — a word you type starting with /) is a multi-step procedure you write down once in a plain text file, give a name, and from then on trigger by that name. The eight-step claims brief becomes a file called pull-claims; typing /pull-claims loads the whole procedure and the AI runs it. You are not re-explaining the routine — you saved it, and now you invoke it. Think of it as turning a recipe you recite from memory into a recipe card in a box: write it down clearly one time, then just pull the card by name. The card never forgets a step and never drifts; you, reciting from memory five times a week, do both.
steps you keep retypingThe multi-step routine that lives in your head and gets re-narrated every fresh chat. Correct, but unsaved -- so it drifts a little each run.
a named .md you write onceThe same steps written down ONCE in a plain text file with a name and a short "use this when..." line. Now there is a single saved copy of the routine -- not your memory.
/name -- one wordYou type the name. The tool loads the saved procedure and runs all the steps the same way every time. One word replaces eight retyped sentences.
The model: a recipe you recite from memory works -- until the fifth time, when you forget the resting step or guess the oven temperature, and dinner comes out a little different. A recipe card in a box is the skill: you write it down once, clearly, and after that you just pull "lasagna" by name and every step is identical. The recitation depends on you remembering perfectly under pressure; the card does not. A skill is that card for a work routine: save the procedure once, invoke it by name, and a job you used to re-explain becomes one word that runs the same way every time.
Coming up, you'll take that eight-step claims brief and write it down once as a named skill -- a file called pull-claims with the steps inside and a short "use this when the user asks to pull the day's claims" line at the top. You save it. Tomorrow the same job comes up. Instead of re-typing the eight steps from memory, you type /pull-claims. What happens?
/pull-claims pull in? You'll watch this exact thing run at the end of the module./pull-claims loads the saved procedure -- the whole eight-step routine, exactly as written -- and the AI runs it. You wrote it down once; from then on one word triggers the full thing, identically every time. You stopped being the manual. Keep this in mind -- at the end you'll run a skill and watch one word expand into the whole routine.pull-claims -- because that name becomes the word you'll type to trigger it.~/.claude/commands/pull-claims.md (a slash command) -- or a skill folder ~/.claude/skills/pull-claims/SKILL.md. The body is just your eight steps in plain English. No code. The file IS the saved procedure.--- lines, add a description: -- one sentence saying when to use it ("Use when the user asks to pull the day's claims report"). That line is how the AI knows which saved routine you mean./pull-claims. The tool loads the saved file and the AI runs the whole routine -- same eight steps, same order, every time. Verify by checking it did all eight, not your memory of seven.Same rule as always: answer it right, or the module isn't done.
CLAUDE.md (D) doesn't store the actual six steps. Which option writes the procedure down ONCE in a named file and lets one word trigger it?/pull-claims: the six steps written down ONCE in a named file, with a "use this when..." line so the AI knows when it applies -- and from then on one word, /close-invoices, loads and runs the whole saved routine, identically every Friday. The sticky note (A) still makes you the carrier; "remember last Friday" (B) fails because a fresh chat is blank; a slogan in CLAUDE.md (D) stores no steps. A skill isn't a faster way to re-type a routine -- it's saving the routine once so a name replaces the retyping. Module unlocked. ↓A procedure you keep re-explaining is a procedure you can save once and call by name. Write the routine down one time as a named skill; from then on one word runs the whole thing the same way every time.
A ready-to-fill SKILL.md template -- the plain text file that turns one routine you keep re-typing into a word you trigger. You drop it at ~/.claude/skills/<your-skill-name>/SKILL.md (a skill -- works in any Claude Code project) or, for a quick one, at ~/.claude/commands/<your-skill-name>.md (a slash command). It already has the two things every skill needs: the frontmatter at the top -- the name and the one-line description between two --- lines that tells the AI when to reach for this routine -- and a numbered body where you paste your own steps in plain English. No code. You fill in the name, the "use this when..." line, and your steps; save; and from then on you type /your-name instead of re-narrating the whole job. Plus SKILL-CHECKLIST.md: a short worksheet that walks any routine you keep re-explaining into a saved, named skill, and flags the one mistake beginners make -- a vague description, which leaves the AI unsure when to use it. You now own a piece of the machine that stops you being the manual -- and this is exactly how a non-coder runs a fleet the ban forced into existence: the workflow only became the asset once the routines stopped living in one person's head and started living in named, triggerable files.
Don't take "it runs the saved procedure" on faith -- watch one word expand into the full routine with your own eyes. Save a tiny skill, then trigger it by name and confirm it ran every step you wrote, not a remembered subset:
One word triggered all eight steps the same way they were written → the procedure is saved, not in your head. Had to re-paste the steps to make it work → you didn't save a skill, you saved a bookmark. The difference between a routine and a skill is exactly this: you can trigger it by name and watch the whole thing run.