Skills & SOPs
Outcome: You'll understand the difference between skills and SOPs, and create your first SOP.
What Is a Skill?
Let's start with Anthropic's definition. A skill is basically a folder with a megaprompt in it. It's an instruction set for LLMs that lives in a specific place.
The technical version:
- Skills live in
.claude/skills/folder - Each skill is a folder containing a
SKILL.mdfile - The SKILL.md has metadata (name, description) plus instructions
- Claude auto-discovers skills and triggers them based on what you're doing
Example: There's a PDF skill. When you say "help me fill out this PDF form," Claude recognizes the task and loads the PDF skill's instructions.
You can invoke skills manually too: Type /pdf or /commit to trigger specific skills.
Anthropic has created skills. The community creates skills. You can create your own skills. There's even an open standard (agentskills.io) so skills work across different AI tools.
But these are not as valuable as your CUSTOMIZED skills... let me explain...
How I Started Doing Something Different
I started creating instruction sets for Claude—detailed guides for how to do specific types of work. Research documents. Scoping plans. Presentation creation.
But I wasn't putting them in .claude/skills/. I wasn't following the SKILL.md format. I was just creating markdown files with really detailed instructions, baking in more context, and dropping them wherever made sense.
When I told people "I made a skill for this," they got confused. They'd ask "where's the SKILL.md?" or "why isn't it in the .claude/skills folder?" It wasn't following the format Anthropic recommended.
Eventually I realized: what I was doing was different enough and confusing to call it a "skill" (according to Anthropic's definition).
The Key Distinction
| Skill | SOP | |
|---|---|---|
| Focus | Execution scaffolding | Substance |
| Contains | Where to save, what phases, file routing, triggers | Domain knowledge, decision frameworks, quality criteria |
| Question it answers | "How and where does this execute?" | "What does 'good' look like?" |
| Works with | Specific tools, specific setup | Any AI, any tool, or a human following it manually |
Skills are about automation logistics—the plumbing.
SOPs are about output quality—the actual knowledge of how to do something well.
The Portability Test
Here's how you know if something is a real SOP:
Can you paste this into any prompt, with any AI, and have it produce useful output?
If yes → it's an SOP. Pure instruction, portable knowledge.
If it only works "when invoked with the right parameters" or "when saved in the right folder" → it's a Skill. Execution wrapper.
SOPs are automation-agnostic. They work whether you're using Claude Code, ChatGPT, Gemini, or a human following the instructions manually.
Why This Matters
Here's how AI output quality actually breaks down:
| Factor | Impact on Quality |
|---|---|
| Context (your SOP/playbook) | ~80% |
| Instructions | ~15% |
| Validation | ~5% |
Most people obsess over Skills (the automation) and ignore SOPs (the quality).
They spend hours perfecting their skill wrapper—triggers, phases, validation rules—around a thin SOP. Then they wonder why the output is mediocre.
You can't validate your way to quality. You have to context your way to quality.
The fix isn't better automation. It's denser context. Better SOPs.
The Bottom Line
Skills and SOPs are both instruction sets for LLMs that live in markdown. The labels almost don't matter.
What matters is understanding:
- Substance (domain knowledge, quality criteria) → this is what makes output good
- Scaffolding (where it lives, how it triggers) → this is just plumbing
If you mix them up, you end up with bloated skills that are hard to maintain, or thin SOPs that produce mediocre output.
Separate the substance from the scaffolding. Build the SOP first. Add the skill wrapper later—and only if you need automation.
When to Create an SOP
SOPs don't just appear at the end of a project. You'll find yourself creating them at different moments:
1. After something works well
You just created a research document and it came out great. The structure was right, the depth was right, the client loved it. Before you move on—capture what you did.
- What context did you provide?
- What prompts worked?
- What made the output good?
2. When something isn't working
You're halfway through writing and notice the tone feels off. It's too formal, or too salesy, or too something. You stop, diagnose the problem, figure out what "right" looks like, and capture that as an SOP so it doesn't happen again.
3. When you notice a pattern
You've done the same type of research three times now. Each time you're figuring it out fresh. That's a sign—capture the pattern so next time you (or Claude) can just follow the SOP.
4. Before you forget
You just solved something tricky. The solution is fresh. If you don't write it down now, you'll forget the nuance. Capture it while it's still in your head.
The Process
- Notice the trigger - Something worked, something's broken, or you see a pattern
- Identify what matters - What made it work? What was wrong? What's the repeatable part?
- Pull in reference if needed - Existing docs, examples, principles that apply
- Capture it - Write the SOP so Claude (or you) can follow it cold
- Apply it - Use the SOP on the next task to validate it works
Hands-On: Create Your First SOP
Step 1: Set up your inputs
Before you prompt, gather what Claude needs:
-
Give Claude the SOP Maker (required)
- Find your SOP Maker SOP (or skill maker)
- Right-click → Copy Path
- This tells Claude the format and structure to follow
-
Create a place for the output (pick one):
- Option A (recommended): Create a blank markdown file ahead of time
- Right-click your SOPs folder → New File →
my-new-sop.md - Copy the path
- This gives Claude a specific target—less chance of it creating files in weird places
- Right-click your SOPs folder → New File →
- Option B: Just give it the folder path
- Copy the path to your SOPs folder
- Tell Claude to create the file there
- Works fine, but Claude might name the file differently than you'd expect
- Option A (recommended): Create a blank markdown file ahead of time
Step 2: Build your prompt
Pick the scenario that fits, then add the SOP Maker and output location:
If something just worked:
Here's my SOP Maker: [paste SOP Maker path]
Help me create an SOP from what we just did. I want to capture the process so I can replicate it. Include: what the task was, what context I provided, what prompts worked, and what the output structure should be. Make this portable—it should work if I paste it into any AI prompt.
Write the SOP to: [paste output file or folder path]
If something isn't working:
Here's my SOP Maker: [paste SOP Maker path]
The [output type] I'm getting isn't right. It feels [too X / not enough Y]. Help me diagnose what's wrong, figure out what "good" looks like, and capture that as an SOP I can use going forward.
Write the SOP to: [paste output file or folder path]
If you notice a pattern:
Here's my SOP Maker: [paste SOP Maker path]
I keep doing [this type of task] and figuring it out each time. Help me capture the pattern as an SOP so next time we can just follow the process.
Write the SOP to: [paste output file or folder path]
Step 3: Review and validate
- Check that it followed the SOP Maker structure
- Portability check: Copy the SOP, paste it into browser Claude (not Claude Code), give it the same task. Does it produce good output? If yes, you have a real SOP.
- Next time you do similar work, start by giving Claude the SOP as context
The habit: When you nail something, capture it. When something breaks, diagnose and capture the fix. The SOPs accumulate. Your work gets more consistent.
Hands-On: Use an Existing Skill or SOP
There are two ways to work with skills and SOPs: create your own, or use existing ones.
Where Skills and SOPs Live
You'll build up a collection over time. For now, know that:
- Your skills repo: This is where you'll store your own skills and SOPs
- Shared collections: Your team may have a shared folder of SOPs
- Community skills: There are public skills you can use
The Process: Always Start by Understanding
When you find a skill or SOP someone else created, don't just use it blind. Start with a question.
Step 1: Ask Claude to explain it
Copy the path to the skill/SOP file, then ask:
Here's a skill/SOP I found: [paste path]
Can you explain what this does? Walk me through how I'd use it and when it applies.
Claude will read it and break it down for you.
Step 2: Decide if it fits your task
Sometimes it's a perfect match. Sometimes it's close but not quite. Both are fine.
Step 3: Use it (fully or partially)
If it's a full match:
Use this SOP to help me [do the task]: [paste SOP path]
If you only need parts of it:
I know this SOP is for [original purpose], but I want to use some of the elements from it.
Here's the SOP: [paste path]
Use the [specific parts—structure, tone, format, criteria] to help me [your actual task].
You can cherry-pick. SOPs aren't all-or-nothing.
Hands-On: Customize an Existing Skill or SOP
Sometimes you find an SOP that's close but not quite right. Instead of starting from scratch, take it and make it yours.
When to Customize
- The structure is good but the content doesn't fit your domain
- The approach is solid but you need different criteria
- You want to combine elements from multiple SOPs
- The SOP works but you've learned improvements
The Process
Step 1: Start with understanding
Here's an SOP I want to customize: [paste path]
Can you explain what this does and break down its key components?
Step 2: Identify what to keep vs. change
I like the [structure/format/approach] of this SOP, but I need to change:
- [What needs to be different]
- [What's missing]
- [What doesn't apply to my use case]
Step 3: Create your customized version
Take this SOP as a starting point: [paste path]
Create a customized version that [describe your changes].
Keep the [parts you want to preserve]. Change the [parts you want different]. Add [anything missing].
Write the new SOP to: [paste output path]
The payoff: You get a tailored SOP in minutes instead of building from scratch.