Chapter 1: What Skills Are and Why They Matter

Every time you start a new Claude Code session, you start from zero. Claude has no memory of what you worked on yesterday, no knowledge of how your project is structured, no idea what tools you’re using or what conventions you follow. You either re-explain it all, or you accept that Claude is working blind.

Skills solve this. Not by giving Claude persistent memory — that’s a different problem — but by making it trivial to load structured context and instructions at the start of any session.

What a Skill Actually Is

A skill is a markdown file. That’s the whole thing. It lives in ~/.claude/skills/[name]/SKILL.md and contains whatever you want Claude to know or do when you invoke it.

The file has a YAML frontmatter block at the top:

---
name: my-skill
description: What this skill does and when to use it
user-invocable: true
---

Below the frontmatter is the actual content — instructions, context, workflows, examples, whatever the skill needs. Claude reads it all when the skill is invoked.

When you type /my-skill in a Claude Code session, Claude reads the file and follows it. The skill might tell Claude to run a series of bash commands, check specific files, format output in a certain way, or apply a particular mental model before responding. You write the instructions once; Claude executes them every time.

Why This Beats Copy-Pasting Prompts

The copy-paste approach to prompting has a few problems:

It doesn’t compose. You have one prompt for code review, another for writing sessions, another for debugging. They live in notes somewhere. You have to find the right one, copy it, paste it, and hope it still works in this context.

It doesn’t evolve. When you learn something new — a better way to structure a retrospective, an extra step the code review was missing — you update your notes, maybe. Next time you grab the wrong version.

It has no relationship to the project. A pasted prompt has no awareness of your CLAUDE.md, your directory structure, your conventions. A skill can read those things, reference them, build on them.

Skills are versioned, organised, and discoverable. They live alongside your project configuration. When you type /morning-brief, you know exactly what’s going to run.

How to Install a Skill

Skills go in ~/.claude/skills/. Each skill gets its own directory containing a SKILL.md file.

# Create the skills directory if it doesn't exist
mkdir -p ~/.claude/skills

# Clone or copy a skill
mkdir -p ~/.claude/skills/morning-brief
# Then add your SKILL.md file

The five skills in this guide are all published at github.com/aplaceforallmystuff. You can clone the whole repository or copy individual skill files.

To invoke a skill once it’s installed, type the skill name with a leading slash in any Claude Code session:

/morning-brief
/log-to-daily
/think-first

Claude will read the file and execute it. If the skill has user-invocable: true in its frontmatter, Claude Code’s autocomplete will also suggest it as you type.

What Makes a Skill Worth Having

Not everything belongs in a skill. A skill earns its place when you find yourself doing the same thing across multiple sessions — same context, same instructions, same workflow. That’s the signal.

The five skills in this guide each represent a repeated pattern:

• Morning brief — a daily ritual that spans calendar, tasks, email, and projects
• Log to daily — end-of-session capture that runs the same way every time
• Draft first — a two-stage writing workflow that always starts the same way
• Think first — a decision process that applies the same mental models to any significant choice
• Lessons learned — a retrospective structure that follows the same seven phases

Each one started as a workflow I was doing manually, with instructions I was re-typing or re-pasting. The skill just made it permanent and invocable.

---

The next chapter covers morning-brief — the one I use every single day.