Capstone: Build Five Real Skills

Breadth Over Depth

Every lesson in this course used one running example — roll-dice — to keep the format itself front and center. This capstone flips that: instead of going deeper on one skill, you’ll build five small ones, each doing a genuinely different kind of job. By the end, you’ll have real, working skills you can actually keep using — and a clear sense of the variety of things a skill can be, which is exactly the foundation the next course in this path, Production Agent Skills Engineering, builds on when it names these jobs formally as design patterns.

The Five Skills

Build one skill for each of these — pick a real task from your own work wherever you can, since a skill you’ll actually use is more motivating to get right than an invented example.

1. A checklist skill. Something with a fixed sequence of steps done the same way every time — a PR description template, a release checklist, an onboarding runbook. The instructions should read like a recipe: step one, then step two, in order.

2. A validation skill. Something that checks input against rules and reports what’s wrong — a commit message format, a config file’s required fields, a naming convention. The output should be specific: not “this is invalid,” but exactly which rule failed and why.

3. A transformation skill. Something that converts one format into another — CSV to Markdown table, a log line into a structured summary, code comments into a changelog entry. Give the agent a clear example of input and expected output, not just a description of the rule.

4. A lookup skill. Something that answers questions using reference material you provide rather than the agent’s general knowledge — your team’s glossary of internal terms, a project’s API quirks, a set of company-specific abbreviations. This is a good place to practice references/ from Files & Resources: put the actual reference material in a file, and have the skill’s body tell the agent when to read it.

5. A feedback skill. Something that reviews a piece of work and gives structured comments — a short writing critique, a simple code-style check, feedback against a rubric you define. The instructions should say what to look for, not just “review this.”

Build Each One Through the Full Lifecycle

For every skill, work through the same sequence you practiced across this course — don’t skip steps just because the skill is small:

1. Anatomy first. Decide, before writing anything, whether this skill needs just a body, or also scripts/, references/, or assets/ (lesson: Skill Anatomy).
2. Write SKILL.md. Get name and description right by the rules from SKILL.md Fundamentals — this matters even for a five-minute skill, since a vague description is the single fastest way to end up with a skill that never triggers.
3. Install it in the location from Skill Discovery that fits how you’ll use it — personal, if it’s about how you work, or project, if it belongs to something you’re building with others.
4. Test it. At minimum, three prompts by hand plus a small labeled query set, per Testing Skills — five skills means five separate small query sets, not one shared one, since each skill’s trigger conditions are different.
5. Publish it, per Publishing Skills — commit it somewhere it’ll actually keep being used, not just in a scratch folder you’ll forget about.

What “Done” Looks Like

By the end of the capstone you should have five skill folders, each independently:

• Passing skills-ref validate with no errors
• Discovered correctly by your agent client
• Triggering correctly on at least 3 manual prompts and a 10-15-query labeled set
• Committed somewhere durable — a personal skills folder you’ll keep using, or a project repository

Notice What You Just Learned, Without Being Told

Go back over your five skills and look at them side by side. A checklist skill and a validation skill don’t just cover different topics — they behave differently: one walks forward through fixed steps, the other branches on whether something passes or fails. A transformation skill is defined almost entirely by its examples; a lookup skill is defined almost entirely by what reference material it points to.

That’s not a coincidence, and it’s not something this course told you to notice — you arrived at it by building five different things and feeling the difference yourself. Skills genuinely come in different shapes, with different design considerations for each. Naming those shapes precisely, and knowing which one a new problem calls for, is where Production Agent Skills Engineering — the next course in this path — starts.

Where to Go From Here

You can now say, honestly: I know how to create and use SKILL.md. That was the whole goal of this course, and five working skills later, it’s true.

If you’re building for a team, the natural next move is exactly what the last lesson covered — commit anything genuinely useful under .claude/skills/ in the relevant repository so everyone benefits automatically, or package it as a plugin if it needs to travel further than one project.

And when you’re ready to go from “skills that work” to “skills that hold up at production scale — patterns, testing, security, versioning, and everything an enterprise skill pack needs” — that’s Production Agent Skills Engineering, the next course in the Agent Skills Engineering Path.