Module 1: What Skills and Agents Actually Are

The word “agent” gets used for everything from a chatbot to a science fiction concept. That’s not useful. Let’s be specific.

A skill is a reusable instruction set. It’s a markdown file with a YAML header. It tells Claude how to approach a specific class of task — what to do, in what order, with what constraints. When you invoke it, those instructions load into context and shape the response.

An agent is a skill with tools. The instructions are the same kind of thing. But now Claude can act — read files, run bash commands, search the web, write to disk. The difference between a skill and an agent isn’t the instructions. It’s the reach.

Where Most People Go Wrong

Most people who use Claude treat every session as a blank slate. They paste context, explain the situation, get an answer, and start over next time. This works. It’s just wasteful.

The friction compounds. Every session you re-explain your writing voice, your commit message format, your preferences for how code should be structured. Claude does the work. You supply the context. Every time.

Skills and agents break this cycle. You write the context once, in a file, and it loads automatically. Your preferences become defaults. Your patterns become reusable. The system gets smarter as you add to it — not by training a model, but by building structured knowledge that loads on demand.

What a Skill Looks Like

Here’s the complete skeleton:

---
name: think-first
description: Enforce mental model application before major decisions. Use when facing architecture choices, business decisions, feature prioritisation, trade-off analysis, or any task where the user asks "should I...?" / "which is better?".
use_when: User faces a decision with trade-offs, compares options, or asks "should I".
user-invocable: true
---

Then a markdown body with the actual instructions.

That’s a real skill — think-first — from the system that this course documents. The YAML header tells Claude Code when to load it and how to surface it. The body tells Claude what to do when it runs.

What an Agent Looks Like

An agent adds a tools declaration:

---
name: draft-reviewer
domain: writing
description: Review AND FIX any draft for AI slop, writing craft, and voice consistency.
tools: Read, Write, Edit, Skill, Glob, mcp__local-llm__local_classify
model: sonnet
---

That tools line is the difference. draft-reviewer can read the draft file, edit it directly, invoke other skills, and call a local language model for pre-classification. It doesn’t just produce advice — it acts.

The model field lets you route tasks to the right capability. Analysis tasks run on Sonnet. Tasks requiring careful judgment might run on Opus. You pick per agent.

The Composability Insight

The interesting thing isn’t individual skills or agents. It’s what happens when you build many of them.

draft-reviewer invokes writing-quality and voice-editor. sbc-writer invokes draft-reviewer. content-pipeline orchestrates the whole sequence: research, draft, review, publish. Each piece does one thing well. The system does complex things by combining pieces.

This is the same principle behind any good software architecture: small, composable units that do one thing reliably. The difference is that here, the units are instruction sets rather than functions.

Why the Distinction Matters

Not everything should be an agent. Agents have tool access, which means they can take action. A skill that only needs to shape a response — a writing voice guide, a decision framework, a structured workflow checklist — doesn’t need tools. Keeping it as a skill means it’s cheaper to run, easier to reason about, and harder to misuse.

The progression is intentional:

1. Start with a skill — pure instructions, no reach
2. Add tools when the task requires action
3. Connect agents when the task requires multiple stages

By the time you finish this course, you’ll have the instinct for which level a given problem needs.

---

The next module builds your first skill from scratch.