A free guide by New Money School
Claude Skills
There are three ways to build a Claude skill. Two of them are guessing. The third is the only one I trust to run in my actual business, and here's exactly how to do it.
A "skill" is just a saved set of instructions that teaches Claude to do a repeatable job the same great way every time, so you never have to re-explain it.
Think of it like hiring someone and writing down exactly how you want a task done, once, so they nail it forever. The question is how you write those instructions. There are three ways to do it, and they are not equal. The first two feel faster. The third is the one that actually gets it right, because it's built around how you work instead of how someone else does.
Way 1Copy Someone Else's Skill
The fastest way. You grab a skill someone already made, from a GitHub repo or from one of my free guides, and drop it straight into Claude.
This is genuinely useful, and honestly a great place to start. A well-built skill for something generic, like formatting a weekly report or cleaning up a spreadsheet, will work for almost anyone. But the second the job touches how your specific business runs, it starts to miss. Everyone's life, offers, tools, and clients are different, and a stranger's skill has none of that context baked in.
Best for: getting started fast + generic, universal tasks.
Weak for: anything specific to how your business actually operates.
Way 2Describe It And Let AI Build It
A big step up. Instead of borrowing someone else's, you describe the skill you want and ask Claude to write it for you. You explain the task, the steps, the output, and it drafts the instructions.
This is better because at least it's your description. But there's still a gap: you're describing how you think you work, from memory, in one sitting. And that's almost never how the job actually goes. You forget the edge cases, the little judgment calls, the "oh, except when it's this kind of client" moments. Claude builds a clean skill for the version of the work in your head, not the messy real one. It's still guessing, you're just the one feeding it the guess.
Best for: a solid first draft when you can't demo the task live.
Weak for: capturing the real judgment calls you make without thinking.
The pattern to notice
Way 1 is someone else's guess at the work. Way 2 is your guess at the work. Way 3 removes the guessing entirely, because you show Claude the real thing.
Way 3 ★ The One I UseRun It, Correct It, Then Save It
This is the only method I fully trust for my own business, and it's shockingly simple: instead of describing the work, you do the work with Claude, once, correcting it in real time. Then you tell it to save that whole session as a skill.
Now the skill isn't built from a template or a memory. It's built from a real run of the task, with your real corrections and your real standard of "good" baked right in. Here's the exact four-step loop.
Step 1
Run the real workflow with Claude
Pick a task you actually do and do it with Claude, live, on a real example. Not a hypothetical, not "imagine you're writing an email," an actual email you need to send today. Walk through the whole thing start to finish.
Step 2
Correct it as it goes
This is the magic step. Every time Claude does something slightly off, fix it out loud. "Too formal, I'd never say that." "Skip that part." "This is exactly right, keep doing it like this." You're not just getting a good result, you're teaching it the difference between good and bad using your real standard.
Step 3
Get it to nail the result
Keep going until the output is genuinely something you'd use without editing. That final version is your bar. Everything before it was training.
Step 4
Tell it to save the whole process as a skill
Now you say the magic words: turn everything we just did into a reusable skill. Claude writes up the process, the steps, and all the corrections you made along the way, so next time it does it your way on the first try.
Here's the prompt I use to kick off Step 1. Paste it, fill in your task, and run your real workflow with it. It forces Claude to watch how you actually work instead of guessing.
Prompt 1 — Run The Real WorkflowCopy
I want to build a reusable skill by doing a real task with you first, then saving how we did it. Do not build the skill yet. We are in training mode.
The task I want to turn into a skill: [describe the repeatable job in one or two sentences, e.g. "write a reply to a customer support email" or "turn my rough notes into a polished LinkedIn post"]
Here's a real example to work on right now: [paste the actual input, the real email / notes / data / brief you're working with today, not a made-up one]
How I want you to work with me: 1. Do the task on this real example, start to finish, in the way you think is best. 2. Go one section or one decision at a time. After each step, pause and ask me "is this right, or what would you change?" before moving on. 3. When I correct you, treat that correction as a permanent rule for this kind of task, not a one-off fix. Restate the rule back to me in one line so I know you caught it. 4. Watch for the small judgment calls: tone, what to include vs cut, formatting, what "done" looks like to me. Ask about them instead of assuming. 5. Do not summarize or offer to save anything as a skill until I explicitly say we're finished. Right now we are just doing the real work together.
Start by attempting the task on the example above, then pause for my first round of feedback.
Once the output is genuinely good, that you'd send it as-is, run the second prompt. This is Step 4: it turns everything you just did into a permanent, reusable skill you can run again tomorrow (or hand to a teammate).
Prompt 2 — Save It As A SkillCopy
That final version is exactly what I wanted. Now turn everything we just did together into a reusable skill I can run again on new inputs and get this same quality on the first try.
Write it as a clean, self-contained skill document with these sections:
1. Name: a short, obvious name for this skill. 2. What it does: one or two sentences on the job and when to use it. 3. Inputs it needs from me: the exact things I have to give you each time (and what to do if one is missing). 4. Step-by-step process: the actual steps we followed, in order, written as instructions to yourself. 5. My rules and standards: every correction I made today, written as permanent rules. Include the tone, what to include vs cut, formatting, and anything I said "always" or "never" about. This is the most important section, do not lose a single one. 6. What "good" looks like: describe the quality bar of the final version we landed on, so you can check your own work against it. 7. Common mistakes to avoid: the things you did on the first pass that I corrected, so you don't repeat them.
Rules for how you write it: - Base it only on what actually happened in our session, not on generic best practices. If you're unsure whether something was a real rule, ask me instead of inventing it. - Write it so a version of you with zero memory of today could pick it up and produce the same result. - Keep it tight and skimmable. No fluff, no restating the obvious.
When you're done, show me the full skill and then ask me the one or two questions that would make it even more reliable.
Where To Keep It
Save that skill document where Claude can reach it every time: paste it into a Claude Project's instructions, drop it in as a SKILL.md file, or if you use Claude Code, save it as a skill in your project. Now the work you did once runs itself forever, built around exactly how you work.