Claude Skill Examples: Real SKILL.md Files You Can Copy

Most guides describe the skill architecture. This one shows the actual files.

The guide to building Claude Code skills covers the fundamentals: what a SKILL.md is, how a loading map works, when a skill is worth building. This article does not repeat that. It shows real examples: files from a library running in production.

Nobody publishes their SKILL.md. Not the ones that actually work. You get architecture diagrams and abstract loading-map explanations, but nothing you can drop into .agents/ and test on Monday. The examples below are from a real library: eight persona skills and sixteen function skills running a daily workflow. Two categories, one architecture, different jobs. This is the disassembly.

The library is a flat folder

Each skill is a subdirectory with a SKILL.md router and, for persona skills, a references/ folder split by decision domain. The library I run has 24 skills across both types. Persona skills are named after people: each one names a recognizable body of work and routes questions to distilled references. Function skills are named after jobs: no persona calibration, just a checklist and an output format.

Skill library: .agents/skills/

alex-hormozi/personaoffer design, pricing, guarantees
- SKILL.mdrouter
- references/15 files, one per decision
neil-patel/personaSEO strategy
russell-brunson/personafunnels, value ladder
gary-vaynerchuk/personacontent, attention
feynman/personadidactic clarity
arthur-miller/personanarrative, script
michael-burry/personacontrarian investing
felipe-fontoura/personabusiness strategy
lifeos-lint/functionwiki health-check
lifeos-review/functionweekly review
lifeos-capture/function
lifeos-ingest/function
lifeos-journal/function
lifeos-plan/function
lifeos-query/function
lifeos-study/function
youtube-analyse/functionvideo performance
narration-review/function

Why naming a person beats generic role prompting, and why references separate the technique from cosplay, is covered in persona skills for Claude Code. The structure above is where it lives day to day.

Persona skill anatomy: alex-hormozi

A persona skill names a person, distills their method into decision-split references, and routes each question to the file that owns that decision. The alex-hormozi skill handles offer design, pricing, guarantees, and retention. The SKILL.md is routing logic only. It does not contain the method. It has 15 references and a loading map the agent must consult before answering.

The frontmatter block is what Claude Code reads to decide whether to invoke the skill:

---
name: alex-hormozi
description: >
  Designs, critiques, and refines commercial offers — products, pricing,
  guarantees, sales ladders, lead magnets, ads, sales copy, retention plays,
  pricing raises, and fast-cash campaigns. Applies: Value Equation, Grand Slam
  Offer, Core Four advertising, ACA closing, Five Horsemen retention, MAGIC
  naming. Output is a single direct recommendation — not a menu of options.
---

The description names the frameworks explicitly. “Offer design” is vague; “Value Equation, Grand Slam Offer, ACA closing” is a coordinate. Claude Code matches the user’s intent against this description to decide what to invoke. Precision in the description is precision in the trigger.

The loading map inside the SKILL.md body is the routing layer:

## Reference loading map

| Reference                                 | When to load                                 |
| ----------------------------------------- | -------------------------------------------- |
| `references/00-canon.md`                  | Core principles — load for any question      |
| `references/01-value-equation.md`         | Pricing, conversion, perceived value         |
| `references/02-grand-slam-offer.md`       | Building or auditing a new offer             |
| `references/03-money-models.md`           | Product sequencing, upsell/downsell logic    |
| `references/04-pricing-and-guarantees.md` | Price raises, guarantee types, risk reversal |
| `references/05-naming-and-positioning.md` | Naming, MAGIC formula, niche strategy        |
| `references/06-advertising-and-leads.md`  | Ad strategy, hooks, lead magnets             |
| `references/07-closing-and-sales.md`      | Objections, sales calls, close rate          |
| `references/08-retention-and-ltv.md`      | Churn diagnosis, LTV, activation point       |
| `references/09-branding-and-proof.md`     | Testimonials, proof factors, brand pairing   |
| `references/10-fast-cash-plays.md`        | Quarterly revenue injection, cash now        |
| `references/11-decision-checklist.md`     | One specific offer — recommended start       |
| `references/12-canonical-phrases.md`      | Calibration — load when tone drifts          |
| `references/13-cfa-math-and-scaling.md`   | CAC/GP math, paid acquisition economics      |
| `references/14-operations-and-scaling.md` | Scaling stage diagnosis, operating rituals   |

Fifteen rows, fifteen decisions. A retention question loads retention, not the whole library. A pricing question loads pricing. Nothing auto-loads; the map makes routing explicit so the model has no room to guess.

alex-hormozi skill at a glance

15
reference files: 80KB
distilled method: 1
SKILL.md router: 0
prompts to repeat

The name activates the corpus. The 80KB you distilled to fill it is the payoff.

Function skill anatomy: lifeos-lint

A function skill has no persona. It is named for the job it does, not the person it channels. lifeos-lint runs a health-check on a personal wiki: orphan pages, ghost links, stale content, layer-type mismatches, harvest debt. No author calibration, no canonical phrases. Just a checklist and a strict output format. The rigor comes from the checks, not from a voice.

The frontmatter:

---
name: lifeos-lint
description: >
  Health-check the Life OS wiki. Use when user says "lint", "health check",
  "orphans", "contradictions", or asks about wiki quality. Finds orphan pages,
  weak connections, ghost links, stale content, premature promotions,
  and layer-type mismatches. Suggests improvements; auto-fixes unambiguous issues.
---

No identity section, no canonical phrases, no author calibration. The description lists trigger phrases directly: lint, health check, orphans, contradictions. The skill activates on job language, not a name.

The body of the SKILL.md is the checklist:

## Checks (in order)

1. **Orphans** — pages in `20-wiki/` with zero inbound `[[links]]`
2. **Weak pages** — fewer than 3 outbound connections
3. **Ghost links** — `[[links]]` pointing to non-existent pages
4. **Contradictions** — conflicting claims across pages
5. **Stale content** — `updated` date older than 30 days
6. **Layer-type mismatch** — study note in worklog folder, or vice versa
7. **Harvest debt** — work-log drafts older than 14 days, never promoted

The output format is equally explicit: a lint report with critical, medium, and suggestion sections, a stats block at the end, and an append to log.md. The model cannot improvise the format. That specificity is what makes the skill useful over time. You can scan the same report shape every week.

If you are deciding whether to build this kind of task as a skill or as an MCP subagent, Claude skills versus MCP subagents covers the boundary.

The loading map is the whole trick

The loading map is the part most SKILL.md files in the wild skip entirely. Without it, the model decides what to read. It reliably favors the weights over your files. It takes the path of least resistance, which is generating from training data rather than loading the reference you spent time building. The loading map removes that choice.

The loading map converts a suggestion into a routing rule. Write the “when to load” column as a pain or decision, not a topic label. “Pricing, conversion, perceived value” routes correctly. “Value equation concepts” does not. It describes a file, not a question. The agent has to match the user’s words against the map; write the map in the language the user brings, not the language of the file.

One more discipline: route to the narrowest file that covers the decision. Do not default to loading 00-canon.md for everything. If the user asks about closing rate, load the closing reference. Canon is for grounding, not for every answer.

Test on real inputs, not toy scenarios

The test is not a word count or a reference count. A skill is ready when it handles a real decision: an actual offer you would price, or an actual wiki run you would check. Hypotheticals do not count.

Before shipping a skill

Required:
The description names specific frameworks or trigger phrases, not just the topic area."Value Equation, Grand Slam Offer, ACA closing" beats "offer design".
Required:
References are split by decision, not by source.pricing-and-guarantees.md beats book-1.md.
Required:
There is an explicit loading map in the SKILL.md body.A suggestion to consult references is not a loading map.
Required:
You tested it on a real input, something from your actual work.A toy example is not a test.
Required:
The output is specific: a recommendation, a checklist verdict, a lint report.A wall of options is not an output mode.
Optional:
The skill is versioned in git.
Optional:
There is at least one real example of a good input and its expected output.

Three unchecked required items means you have a concept, not a skill.

The first five are required. The last two raise the ceiling on consistency but are not blockers. Start with the decision you face most often. That is the first reference. Add more when a real input reveals a gap the existing references cannot fill.

The architecture is the easy part

A SKILL.md router, references split by decision, a loading map: the guide to building Claude Code skills explains all of it in a couple thousand words. The hard part is building real references and testing on real inputs.

The examples here are from a library in production: an offer-design skill with 15 decision-split references and a routing table that covers everything from pricing to retention, and a wiki auditor with no persona and a checklist that catches seven categories of structural debt. Both took several real inputs to get right.

Build them for the work you repeat every week. Not for demos.

What is the difference between a persona skill and a function skill?

A persona skill names a person and activates their method: frameworks, decision criteria, canonical phrases, all distilled into references split by decision domain. It works when there is a real public corpus behind the person: books, talks, playbooks.

A function skill names a job. No author calibration, no canonical phrases. The rigor comes from the checklist and the output format. Use a persona when the method lives in a person's body of work. Use a function when the method is a technical checklist.

Why split references by decision instead of by source?

Because the user's question arrives as a decision, not a book chapter. A question about churn loads the retention reference. A question about pricing loads the pricing reference.

If your files are named book-1.md and transcript-3.md, the loading map cannot route by decision. It routes by source, which is wrong. The split by decision is what makes the map usable.

Does a loading map auto-load files when the skill triggers?

No. Nothing auto-loads. The loading map is an instruction the model must follow: a table that tells the agent which file to open for each type of question.

Without it, the model decides what to read. It will usually pick nothing and answer from training data. The map removes that choice by making routing explicit and non-optional.

How many references does a skill need before it is useful?

Three to five, if each one owns a clear decision. The alex-hormozi skill started with five references covering offer construction, pricing, and closing. The other ten were added over time as real inputs revealed gaps.

Start with the decision you face most often. That is the first reference. Add more when the skill fails on something it should have handled.

Can a function skill have a loading map?

Yes. lifeos-lint does not have a loading map because it has no references. The method is entirely in the SKILL.md body. But a more complex function skill (a security auditor, a migration planner) should have references split by check type and a map that routes accordingly.

The loading map concept applies to any skill with multiple reference files, persona or not.