7.1 What Skills Are

You now have three ways to shape your agent: CLAUDE.md (always-on rules), custom commands (named prompts), and briefs (per-task direction). Skills are the fourth — and the most powerful: packaged capabilities the agent discovers and loads on demand, exactly when a task calls for them. This lesson locates Skills precisely in that toolkit, because knowing which tool shapes what is the actual expertise.

What you will learn

• Define a Skill and its key property: model-invoked, loaded on demand.
• Place Skills correctly among CLAUDE.md, commands, and briefs.
• Recognize which of your recurring know-how deserves Skill packaging.

Builder principle

Rules for always, commands for when you say, Skills for when the work calls for it. File know-how by its trigger.

The definition

A Skill is a folder — instructions, optional reference files, optional scripts — that teaches the agent how to do one kind of thing well. The agent sees a catalog of available Skills and pulls one in when the task matches.

The operative phrase: when the task matches. A command runs when you type its name. A Skill activates when the agent recognizes the situation — you say "prep the newsletter" and it reaches for your newsletter Skill the way an experienced colleague reaches for the team checklist, unprompted.

Why on-demand loading matters

This is Chapter 5 economics resolving a real tension. You have know-how worth maybe 2,000 words — your full newsletter process, your client-site checklist, your data-validation standards. Where does it live?

• In CLAUDE.md? It's now spending 2,000 words of context every session, including sessions about something else entirely. Multiply by five processes and your always-on context is bloated with sometimes-relevant material — principle 2 (wrong things out) violated at scale.
• Re-pasted in briefs? You're the loading mechanism. You'll forget, or shorthand it, or be on vacation.
• In a Skill? The catalog entry costs a couple of lines always-on (name + when-to-use). The full 2,000 words load only in sessions that need them. Right things in, wrong things out, durable over repeated — all three principles, simultaneously.

Skills are context engineering's answer to expertise: cheap to carry, fully loaded exactly on demand.

The four tools, one table

Tool	Trigger	Scope of influence	Best for
CLAUDE.md	Always loaded	Everything, lightly	Identity, conventions, boundaries, maps
Brief	You, per task	This task, deeply	The specific outcome and its done-means
Command	You, by name	This moment	Routines you remember to fire
Skill	The agent, by relevance	This kind of work, expertly	Know-how the work should summon

The diagnostic question when filing new know-how: "who should remember this — me or the agent?" The /wrap routine fires when you decide a session's over: command. Your invoice-formatting standards should apply whenever invoices are being touched, whether or not you remembered to mention it: Skill.

What makes good Skill material

Strong candidates share three properties (notice the overlap with 6.5's automation filter — Skills are rungs 2 of that ladder):

1. Recurring kind-of-work — not one task but a category: "building landing-page sections," "writing YouTube descriptions," "reviewing pull requests my way."
2. Has a right way — you hold opinions, standards, or steps that a smart generalist wouldn't guess. If any competent agent would do it identically without the Skill, there's nothing to package.
3. Fits in words and files — expressible as instructions, examples, checklists, maybe a script. (Nearly everything is; "taste" mostly decomposes into examples + rules, as your writing CLAUDE.md proved in 6.4.)

🌱 No-code lane⚙️ Engineer lane

Your first Skills are hiding in your journal and your .claude/commands/ folder — any command whose file keeps growing extra instructions and "oh and also" clauses is a Skill embryo. And processes you learned in this course count: your discovery-file method, your rude-test pass, your research-with-sources format. Packaging course know-how is a legitimate and excellent start.

Think of Skills as the agentic analog of a shared library: encapsulated capability, versioned, reviewable, distributable. The team-scale implications land in 7.4, but start noticing candidates now: the deploy checklist that lives in Chad's head, the code-review standards in that wiki page nobody reads, the migration procedure you re-derive quarterly. Every one is currently unpackaged expertise — load-bearing and unwritten is the worst combination.

Try it now

Build your Skill shortlist (paper exercise — the building starts next lesson):

1. List five pieces of your know-how that recur. Mix life and work.
2. Score each against the three properties. Kill the ones any competent agent would nail without you.
3. For the survivors, write the one-line catalog entry: "USE WHEN: ..." — if you can't finish that sentence crisply, the Skill isn't ready to exist yet.
4. Star the winner: recurring weekly, clearly has your right way, obviously expressible. That's next lesson's build.

Check your understanding

• What's the key difference between how a command activates and how a Skill activates?
• Explain the context economics: what does a Skill cost always-on vs. loaded?
• Who-should-remember-this: file these — your git-commit message format · the end-of-session wrap · your client-proposal structure.
• What are the three properties of good Skill material?