15. Skills
Note: The video covers material not in the guide below — please watch in full.
Action Step
Complete this before moving on.
Create your first skill. Use the Skill Maker from the Skills and SOPs repo and tell Claude to create a skill for writing client research briefs — it should include pulling the client transcript, using the LeanScale brand tone, and following the brief template structure from the previous training. Have Claude write the skill into a new folder in your repo. Once it's created, open the skill file and review what it produced.
Training Guide
Remember the Matrix? Neo sits in a chair, they plug him in, and thirty seconds later he opens his eyes and says "I know kung fu." They uploaded the knowledge directly into his brain.
That's what a skill is. It's an instruction file — written in plain language, saved as markdown — that you load into your AI agent. Instead of explaining from scratch every time how you want a research brief done, or what your brand tone sounds like, or how to structure a project plan, you hand it a file that already contains that knowledge. The AI reads it, and now it knows how to do the thing.
No code. No plugins. Just a document with clear instructions that the AI follows.
(Let's talk about where this came from)
A Quick History
In late 2025, Anthropic introduced skills as an official feature of Claude Code. The idea was simple: let people package up instructions, scripts, and resources into a folder that Claude could load when needed. It was a hit. By December 2025, Anthropic published skills as an open standard — meaning other AI platforms could adopt the same format. And they did. Skills quickly became an industry-wide concept. There's even a standardized format at agentskills.io so that skills built for one platform can work on another.
This matters because the skills you build aren't locked to Claude Code. The format is portable. But more importantly, it means there's a growing library of skills — built by Anthropic, by the community, by other companies — that you can use.
(So how do they actually work?)
How Skills Work
Remember the 200,000 token context window — your AI's working memory? All a skill does is load a specific markdown file into that memory. That's it. When you invoke a skill, you're just putting instructions into the agent's brain so it knows how to do something.
What makes skills special is discoverability. Skills live in a specific folder — .claude/skills/ — and each one has a small header at the top called front matter that describes what the skill does and when to use it. When you launch Claude Code, it automatically reads the front matter of every skill in that folder. It doesn't load the full instructions yet — just the descriptions. So it knows what's available.
Then, based on what you ask it to do, Claude can automatically fire the right skill. Ask it to help you fill out a PDF? It loads the PDF skill. Ask it to commit your changes? It loads the commit skill. You don't have to tell it which skill to use — it figures it out from the front matter.
You can also trigger skills manually with slash commands. Type /commit or /pdf and you're directly invoking that skill. Same result, just explicit.
But strip away the folder structure and the front matter, and a skill is really just a prompt — a context file that tells the AI what to do and how to do it. The .claude/skills/ folder and the front matter are just the delivery mechanism. The actual value is the instructions inside.
(OK — that's the official version. At LeanScale, we took this a step further)
SOPs — Same Idea, More Flexible
At LeanScale, we started creating instruction files before skills were even an official feature. Detailed step-by-step guides for how to do specific types of work — research briefs, scoping documents, client presentations, project plans. We called them SOPs (Standard Operating Procedures).
An SOP is basically a skill. Same concept — a markdown file with instructions that you load into the agent's context. But there are two key differences:
SOPs don't live in the .claude/skills/ folder. That means they're not automatically discoverable — Claude won't fire them on its own. You invoke them manually by copying the file path and pasting it into your prompt. The upside? You can organize them however you want. They can live in your personal repo, in a team folder, inside a project — anywhere that makes sense for your workflow.
SOPs don't have to follow the standard skill format. A skill has specific front matter, a specific structure. An SOP can be anything — a massive step-by-step guide, a checklist, a decision framework, a template with instructions. Whatever format works for the knowledge you're capturing.
The benefit is flexibility. Your SOPs live alongside the work they support, and they can be as detailed or as simple as you need.
(Don't overthink the distinction)
They're the Same Thing
A skill and an SOP are both just markdown files with instructions that get loaded into your AI's context window. One lives in a special folder with auto-discovery. The other lives wherever you want and you invoke it manually. That's the only real difference.
At LeanScale, you'll hear both words used interchangeably. If that's confusing — just call everything a skill. The concept is what matters: you're uploading knowledge into the agent's brain so it knows how to do the work. The better the skill, the better the output. Remember in the file system training — you gave Claude a transcript, a template, and a brand tone file, and the output was dramatically better than just saying "write me a brief." Skills are how you make that repeatable.
(But what happens when the AI doesn't follow the skill?)
When It Doesn't Follow Instructions (Skill Adherence / Prompt Engineering)
You'll run into this. You give it a skill with clear instructions, and the output skips a step, changes the format, or doesn't quite match what you asked for. This is normal — and it connects back to how AI actually works.
Remember: the AI is a prediction machine, not a rule follower. It's pattern-matching based on everything in its context window. Most of the time it follows your skill closely. But sometimes it drifts — especially when instructions are vague, when there's a lot of competing context, or when steps aren't clearly separated.
This is where prompt engineering comes in. It's just the practice of writing instructions that the AI follows more reliably. You don't need to be a developer to do this. Three things help the most:
Be specific with numbered steps. The AI pays closer attention to clear 1-2-3 sequences than to long paragraphs of description. If you want it to do things in a specific order, number them. If a step has sub-steps, indent them. The more structured your skill, the more closely the AI follows it.
Put the most important instructions first. Research shows that LLMs pay more attention to what's at the top of the instructions. If there's something the AI absolutely must do — a specific format, a required section, a quality check — put it early in the skill, not buried at the bottom.
Show an example of what "good" looks like. Instead of just describing the output you want, include an actual example in the skill. When the AI can see what the finished product looks like, it matches the pattern much more reliably than when it's working from a description alone.
This is where the power of "file writing access" comes in handy (and why Agent Platforms shine). When the AI misses something, you go back to the skill and make that instruction more explicit. When it nails something, you leave it alone. It's iterative — each revision makes the skill tighter and the output more consistent.
(So when should you actually create one?)
When to Create a Skill
You'll feel the trigger. Four common moments:
After something works well. You just created a research doc and it came out exactly right. Before you move on — capture what you did. What context did you give? What made the output good? Write it down so you can repeat it.
When something isn't working. The output feels off — too formal, too vague, wrong structure. Stop, figure out what "right" looks like, and capture that. Now it won't happen again.
When you notice a pattern. You've done the same type of task three times and figured it out from scratch each time. That's a signal — capture the pattern so next time you just load the skill.
Before you forget. You just solved something tricky. The solution is fresh. If you don't write it down now, the nuance disappears. Capture it while it's still in your head.
(Let's actually make one)
Guided Demo: Create Your First Skill
Remember the client research brief you built in the file system training? You gave Claude a transcript, a template, and a brand tone file, and it wrote a solid brief. Now imagine you need to do that again for the next client. And the one after that.
Instead of remembering which files to attach and what instructions to give every time, let's capture that entire process as a skill.
In your Skills and SOPs repo, there's a Skill Maker — a skill for making skills. It tells Claude the format and structure to follow.
- Find the Skill Maker in your Skills and SOPs repo — right-click it → Copy Path
- Create a blank file in your personal repo — right-click → New File → name it
client-research-brief.md→ copy that path too - Give Claude both paths and tell it what to capture:
"Here's my Skill Maker: [paste path]. I want to create a skill for writing client research briefs. It should include: pull the client transcript, use the LeanScale brand tone file, follow the brief template structure, include a company overview, key stakeholders, pain points, and recommended approach. Write the skill to: [paste output path]."
Claude reads the Skill Maker, follows the format, and writes your new skill. Now the next time you onboard a client, you just load client-research-brief.md and the AI already knows the process — what files to pull, what sections to write, what tone to use. No re-explaining.
(You don't have to build everything from scratch though)
Using and Customizing Existing Skills
Your Skills and SOPs repo already has skills that the team has built. Before creating something new, check what's already there. If you find one that's close to what you need, ask Claude to explain it:
"Here's a skill I found: [paste path]. Can you explain what this does and how I'd use it?"
If it fits — use it. If it's close but not quite right — customize it. Copy it to your personal repo, then tell Claude what to change:
"Take this skill as a starting point: [paste path]. Create a customized version that [describe your changes]. Keep the [parts you want]. Change the [parts you don't]. Write it to: [paste output path]."
The skills accumulate over time. Every time you capture what works, your AI gets better at your specific work. Every time you customize a team skill, it gets tailored to how you operate. This is how you go from "using an AI tool" to having an AI that knows how you work.
This is the new way work compounds. In the old world, you got faster through experience — but that experience lived in your head. Now, every time you build or refine a skill, you're creating an asset — a personal workflow that automates your work and gets better the more you use it. Your skills are your competitive advantage, and they compound.
(Last one: connecting your AI to external systems — that's MCPs and APIs)
Comment in Slack
Post your answer in your onboarding channel.
What was your biggest takeaway(s) from this training?