What is a skill?

A reusable instruction file that teaches your agent how to do a task the way you'd want it done — and when to reach for it.

• Not a one-off prompt. A file you keep, share, and reuse.
• The how = instructions, format, guardrails.
• The when = the description your agent reads to decide to use it.

A skill is just a Markdown file

Four parts. That's the whole anatomy — remember these and you can read (or write) any skill.

description + instructions are the spec. Format & guardrails are conventions that make skills reliable.

→ The format spec: Agent Skills · agentskills.io

The skill I stole — then got stolen from me

submit-pr-review — turns a diff into a PR review request, drafted the way I'd write it.

• In my environment we don't have automated Copilot PR reviews — so I set out to build my own.
• Then I found Matt Pocock's skills repo, took his, and made it mine.
• Two weeks later my teammates got envious — they wanted to see how I made it, and how to use it.
• I stole and adapted — exactly what I'm telling you to do. Then it happened to me.

Let's review a real PR — right now

submit-pr-review on github.com/fpigeonjr/ai-guild-talk · PR #8

• The skill reads the diff, runs the review, and drafts a verdict — Request Changes or Approve.
• Watch for the approval gate: it drafts, then stops and waits for me. Nothing posts until I say so.
• I approve → it posts to GitHub. The output isn't perfect — it's ready to edit and send.

If the live gods are unkind: the drafted review is in my notes — we'll read it and move on.

Four parts, in the wild

---
name: submit-pr-review
description: Turns a code review into an approved GitHub
  PR review and submits it only after human approval.   # ← WHEN
  Use when the user wants to post or submit a review...
allowed-tools: Read Grep Glob Bash                          # ← GUARDRAIL
---

# Submit PR Review                                        # ← HOW (instructions)
Identify the PR. Run the review. Turn findings into a
draft. Do not post anything until the human approves      # ← GUARDRAIL
the exact review body.

## Write the Review                                       # ← FORMAT
1. Must fix before merge
2. Should verify before merge
3. Suggestions and notes

This one's a wrapper: it doesn't re-invent reviewing — it calls my code-review skill, then shapes the output using a separate REVIEW-FORMAT.md. Skills compose — small pieces, stacked.

→ The real skill: github.com/fpigeonjr/skills · submit-pr-review

This one has nothing to do with code

grill-me — interviews you about a plan until it's sharp. Same four parts. No diff, no repo.

Same skeleton — zero code

---
name: grill-me
description: Interview the user relentlessly about a plan
  until reaching shared understanding.                  # ← WHEN + WHAT
  Use when the user wants to stress-test a plan...
allowed-tools: Bash                                        # ← GUARDRAIL
---

Interview me relentlessly about every aspect of this plan.        # ← HOW
Walk down each branch of the design tree, one-by-one.

Ask the questions one at a time.                            # ← FORMAT

Same four parts as the PR skill. No diff, no repo, no code in the body — just plain instructions. That's the whole thing.

From a hallway ask to a real issue

I met with the UX team last week. They wanted a theme picker for the deck — but we never got to specifics.

• There's no ticket for this yet. Just a vague, good idea.
• grill-me interviews me — one question at a time — until the fuzzy ask has edges: which themes, what a switcher does, how it persists.
• Then to-issues slices the sharpened plan into grabbable tickets — and won't file a thing until I approve the breakdown. Two skills, chained. The second human-in-the-loop gate you'll see today.

No code in either one. This is the skill for everyone — the work is thinking, not typing.

How far does this go?

teach — a stateful skill that generates whole HTML lessons, cheat sheets, and a learning plan.

• Not single-shot — it's a persistent system across sessions.
• So I pointed it at Matt Pocock's skills repo — the one I stole from in slide 1 — and had it teach me.
• The point: skills scale way up… but you don't start here.

Not one file — a workspace

That's what makes it stateful: teach keeps state on disk.

• MISSION.md — why I'm learning it. Grounds every choice.
• GLOSSARY.md — locked terminology, enforced everywhere.
• learning-records/ — what I've grasped, so it knows what's next.
• lessons/ · reference/ — the output you're about to see.

Same idea as the PR and grill skills — just… more of it. This is the ceiling, not the on-ramp.

A whole course — built by a skill

→ fpigeonjr.github.io/learning-pocock-skills

• Lessons, a reference section, a tracked resource list — a real, growing site.
• I started it days ago; teach keeps adding lessons across sessions. That's the “stateful” part — it remembers where we are.
• A skill, about skills, teaching me from the repo that started this whole talk. The tail, meet the head.

You don't even write it by hand

write-a-skill — a skill whose whole job is interviewing you and writing the skill for you.

So the barrier isn't skill.
It's noticing the one task — and you just learned the tell.

→ Steal this one too: github.com/fpigeonjr/skills · write-a-skill

None of these made me faster.

They removed the friction that stopped me from doing the thing at all.

Your homework assignment

The repo link is in the chat. Try it once. That's all it takes.

Questions?

Deck + skills repo: github.com/fpigeonjr/ai-guild-talk