Skills & Shortcuts

If you explain the same thing to Claude twice, that's a skill waiting to be saved.

What you're building today

You're going to identify one workflow you repeat constantly, package it as a skill Claude can run on command, and set up a keyboard shortcut that saves you 30 seconds every time you use it. Multiply that by 10 uses a day.

Step 1: Find your repeating workflow

Think about the last week. What did you explain to Claude more than once? What do you do 5+ times a week that follows the same pattern?

Examples for creative directors:

• Reviewing a deck and giving structured feedback
• Turning meeting notes into action items
• Drafting client emails from rough bullet points
• Organizing reference images into mood boards
• Prepping for a call (research the person, draft talking points)

Pick one. The simplest one. That's your first skill.

Step 2: Create the skill folder

mkdir -p ~/strategy/skills/[your-skill-name]

A skill has one required file: SKILL.md. That's the instruction set. Claude reads it when you invoke the skill.

Step 3: Write your SKILL.md

Tell Claude what you want:

I have a workflow I repeat all the time: [describe it].
Create a skill for it at skills/[name]/SKILL.md.

The SKILL.md should include:
- When to use this skill
- Step-by-step instructions for Claude to follow
- What the output should look like
- Any preferences about tone, format, or structure

Use my words, not generic language.

Claude writes the instruction file. Review it. Edit it. It should sound like you giving directions to a sharp assistant.

Step 4: Test it

Open Claude in your strategy folder and reference the skill:

Use the skill at skills/[name]/SKILL.md to [do the thing]

Watch Claude follow your instructions. If the output is 70% right, tell it what to change. Refine the SKILL.md until it nails your workflow.

# Meeting Notes Processor

## When to use
After any meeting where I have rough notes or a transcript.

## Instructions
1. Read the notes or transcript
2. Extract every action item mentioned
3. Group by person responsible
4. Add deadlines if mentioned, flag "no deadline" if not
5. Format as a checklist I can paste into Slack

## Output format
- **[Person Name]**
  - [ ] Action item (by [date] or "no deadline")

## Preferences
- Be direct. No filler.
- If something is ambiguous, flag it, don't guess.
- Keep it short. I'll add context if needed.

Step 5: Keyboard shortcuts as leverage

You already have Shift+Cmd+Q from Lesson 01. But there's more you can do.

The idea: any action you take 10+ times a day should be one keystroke. Even saving 3 seconds per use adds up. At 15 uses a day, that's 45 seconds. Over a week, 5 minutes. Over a year, 4+ hours. From one shortcut.

To add more Hammerspoon shortcuts, open your config:

-- Example: Shift+Cmd+N to open a new capture in your brain inbox
hs.hotkey.bind({"cmd", "shift"}, "N", function()
    hs.applescript([[
        tell application "Terminal"
            activate
            do script "cd ~/strategy && claude 'Create a new file in brain/00-inbox/ for a quick capture. Ask me what I want to capture.'"
        end tell
    ]])
end)

Advanced: Skills that teach Claude

Most skills automate a task. The interesting ones change Claude's behavior permanently. Here are six that form a system. Together they prevent mistakes, correct the ones that happen, capture everything, and let you step away.

The loop: /preflight and /calibrate prevent mistakes before they start. /principal and /teach correct the ones that get through. /learn captures everything. And once enough lessons compound, /walk-away becomes possible. You stop supervising and start directing.

Deep dive: /principal

When Claude makes a mistake, instead of just correcting it, this skill diagnoses the principle underneath the surface rule, designs a structured encounter with that principle, and saves it to a knowledge system. Four steps, 82 lines:

# Step 1: Diagnose the principle (not just the surface rule)
SURFACE RULE    "Don't refactor adjacent code when fixing a bug"
PRINCIPLE       Scope Discipline: the requester defines the boundary.
                Proximity is not permission.

# Step 2: Design the encounter (concrete, not abstract)
ENCOUNTER: scope-discipline
VIOLATION    Refactored working drag-and-drop while fixing a bug
PRINCIPLE    The requester defines the boundary
COUNTER-CASE Should have: read the bug, fixed only that code path,
             tested drag-and-drop still works, committed a 4-line diff
RULE         If the user didn't ask you to touch it, don't touch it

# Step 3: Persist (so it compounds across sessions)
# Step 4: "Back to your bug."

What makes this different from a regular skill:

• It consolidates, not accumulates. Three scattered rules in your CLAUDE.md collapse into one principle. Your config gets shorter, not longer.
• It self-triggers. Claude checks its own behavior against known principles before acting. One quiet bracketed line, no ceremony.
• It compounds. Every encounter is saved. Repeated violations go deeper. The lessons persist across sessions.

You don't need to build all of these today. But know that skills can go beyond "do this task for me" into a system where Claude prevents mistakes, learns from the ones that get through, and eventually earns enough trust that you can walk away. That's where the real leverage lives.