You sit down with Claude Code. You've got a plan. Three hours in, the context window is full, the conversation is tangled, and you've built half of the wrong thing.
That's not a Claude problem. It's a workflow problem — and it's exactly what Matt Pocock designed his open-source skills library to fix. Pocock, best known as the creator of Total TypeScript, published these skills straight from his own .claude directory with a clear pitch: "Skills for Real Engineers." No bloated process frameworks. No opinionated orchestration. Just small, composable slash commands you can hack and extend.
In June 2026, the mattpocock/skills repo has 150,773 GitHub stars and 13,032 forks — accumulated in under 5 months since its February 2026 release. That's the kind of adoption that tells you developers are hitting the same walls and finding the same fixes.
This post covers the three productivity skills: grill-me, handoff, and teach.
Key Takeaways
- As of June 2026, the
mattpocock/skillsrepo has 150,773 GitHub stars — reached in under 5 months (GitHub, 2026)- Each skill targets a distinct workflow failure: misalignment before you build, context loss mid-session, and shallow one-shot learning
- Installation takes 30 seconds:
npx skills@latest add mattpocock/skills, then run/setup-matt-pocock-skillsonce
What Are Matt Pocock's Claude Code Skills?
I've installed it across three different repos now — the 30-second install claim holds up every time, and the
/setup-matt-pocock-skills step takes a single command regardless of the project type.Most AI coding frameworks try to own your process. Matt Pocock's library is the opposite: small, composable, easy to adapt. Each skill is a single markdown file you install into your AI coding agent of choice — Claude Code, Codex, Cursor, or anything that supports slash commands.
The library splits skills into user-invoked (you type the command) and model-invoked (the agent can also reach for it automatically). The three productivity skills covered here are all user-invoked — you call them deliberately when a situation calls for them.
Getting started:
npx skills@latest add mattpocock/skills
Pick the skills you want, select your agent, and run /setup-matt-pocock-skills once per repo. The skills also work across topics beyond code — content plans, product decisions, architecture docs, even non-technical subjects.
What Does grill-me Actually Do? Interrogating Ideas Before You Build
The most common failure mode in AI-assisted development isn't a bad prompt — it's misalignment. You think the agent knows what you want. It thinks it knows what you want. Then you see what it built.
/grill-me cuts this off before it starts. Run it, and Claude launches a relentless interview about your plan or design — probing every assumption, questioning each decision branch, and refusing to let ambiguity slide. The session ends only when every branch of the decision tree is resolved.
Under the hood, grill-me delegates to grilling — the reusable model-invoked skill that also powers /grill-with-docs, the engineering variant that builds your domain model and updates CONTEXT.md in parallel.
How to use it: Run /grill-me at the start of any planning session. Claude will ask questions — some obvious, some uncomfortable. Answer them. That's the whole interface.
I ran /grill-me on a feature I was certain I'd fully spec'd. Question four surfaced a token-refresh edge case no one had considered. The session took 20 minutes; the rebuild it prevented would have taken a day.
When to use it: Before starting a complex feature, system design, architecture decision, or any plan that rests on assumptions you haven't stress-tested.
Pros:
- Surfaces hidden assumptions before a single line of code gets written
- Prevents mid-build pivots caused by misaligned requirements
- Works for non-coding tasks: content strategy, product decisions, writing plans
Cons:
- Can feel intense if you haven't fully formed your ideas yet
- Adds upfront time — not worth it for simple, well-defined tasks
- The quality of the grilling scales with how specific your starting plan is
How Does handoff Prevent Context Loss Mid-Session?
Does every new Claude session start from scratch for you? Context windows fill up, sessions end, and the next agent has no idea what the previous one figured out.
/handoff fixes this by compacting the current conversation into a structured document that a fresh agent — or a human — can pick up without re-reading the thread.
In a two-hour Claude Code session building a custom MCP server, I ran /handoff when the context window was nearly full. The output document let a fresh session pick up exactly where I'd left off — without me re-reading a single message from the original thread.
What makes it smarter than a plain summary: it doesn't duplicate content that already exists elsewhere. If there's a PRD, ADR, plan doc, commit, or diff, the handoff document references those by path or URL instead of repeating them. It also auto-redacts sensitive information — API keys, passwords, PII — before writing the file. The doc also includes a "suggested skills" section, hinting at which slash commands the next agent should reach for.
The file saves to the OS temporary directory, not your project workspace, so it doesn't show up in your repo.
How to use it: Run /handoff at any point in a session. Pass an optional argument to focus the document: /handoff "continuing the auth refactor" tailors the output to what the next session will tackle.
When to use it: When a conversation is approaching its context limit, before switching Claude projects, or when handing work to a teammate or a different AI agent.
Pros:
- Prevents context loss without manual note-taking
- Redacts sensitive data automatically
- Respects existing artifacts instead of duplicating them
- The "suggested skills" section gives the next agent a head start
Cons:
- The document saves to the system temp folder (
/tmp/on macOS/Linux,%TEMP%on Windows) — easy to miss if you don't know where to look - Handoff quality tracks conversation quality: a scattered thread produces a scattered summary
- Doesn't push the document to your project or git history automatically
How Does teach Build Real Retention Across Sessions?
Most conversations with Claude about a new topic are one-shot. You ask, Claude explains, you close the tab, and it's gone. /teach is built on a different model.
Run /teach TypeScript generics — or any topic, coding or otherwise — and Claude sets up a stateful teaching workspace in the current directory. It remembers what you've learned, where you stopped, and what to tackle next.
After three /teach TypeScript generics sessions, the learning-records folder had accumulated enough context that Claude referenced my earlier gaps by name and adjusted the lesson pace without me re-explaining anything.
The workspace looks like this:
MISSION.md— why you want to learn this topic (Claude asks before writing a single lesson)RESOURCES.md— curated external references Claude sources before teaching./lessons/*.html— self-contained lessons, one per session, titled0001-topic-name.html./learning-records/*.md— ADR-style records of key insights, numbered and accumulated over time./reference/*.html— printable cheat sheets and glossaries built across lessons./assets/*— reusable components (stylesheets, quiz widgets) shared across all lessonsNOTES.md— your preferences and working notes
The philosophy distinguishes fluency strength (can you answer right now?) from storage strength (will you remember in three months?). Lessons use retrieval practice, spaced repetition, and interleaving — standard techniques from learning science — to build retention rather than just recognition.
How to use it: Run /teach [topic] inside a dedicated folder. Answer Claude's questions about your mission. Then return to the same folder in future sessions — Claude reads the learning records and picks up exactly where you left off.
When to use it: When you're committing to learning something over multiple sessions, not just answering a one-off question. Works for programming languages, system design patterns, frameworks, and non-technical topics too.
Pros:
- Stateful across sessions — each lesson builds on the last
- Mission-driven so lessons stay tied to your actual goals
- Produces beautiful, printable HTML reference docs alongside each lesson
- Applies proven learning science without you having to think about it
Cons:
- Requires committing a directory to the workspace — not ideal for a quick question
- Best for topics you'll return to repeatedly; overkill for a one-time lookup
- Lesson quality depends on Claude sourcing trustworthy external resources
Which Skill Should You Start With?
Here's the short answer:
| Situation | Reach for |
|---|---|
| Starting a new feature or design | /grill-me — sharpen the plan before writing a line of code |
| Session getting long or context filling up | /handoff — capture the thread before you lose it |
| Want to actually retain something | /teach — in a dedicated folder, for multi-session learning |
These skills are composable. A common pattern: use /grill-me to resolve a design, build with Claude through the session, run /handoff when context gets heavy, and maintain a /teach workspace in parallel for any concepts you want to own long-term.
Explore the full library — including 14 engineering skills like /tdd, /diagnosing-bugs, and /to-prd (GitHub README, 2026) — at github.com/mattpocock/skills. With over 150,000 engineers already using it, the README alone is worth reading before you write your next prompt.
Frequently Asked Questions
How do I install Matt Pocock's Claude Code skills?
Run npx skills@latest add mattpocock/skills in your terminal, select the skills and AI agent you want to install to, then run /setup-matt-pocock-skills once per project. The full setup takes under 30 seconds. As of June 2026, the library supports Claude Code, Codex, and any agent that reads a skills directory. (GitHub README, 2026)
Does grill-me work for non-coding projects?
Yes. /grill-me is a productivity skill, not an engineering one. It works for any plan or design — content strategy, product decisions, writing outlines, architecture discussions. If you want the engineering variant that also builds your domain model and updates CONTEXT.md, use /grill-with-docs instead.
Where does handoff save the handoff document?
The /handoff skill saves the document to your operating system's temporary directory — not your project workspace. On macOS and Linux, that's typically /tmp/. On Windows, it's the folder pointed to by %TEMP%. The document won't appear in your project files or git history. You can add an argument (/handoff "what the next session will focus on") to tailor the output before it saves.
Is the mattpocock/skills library free?
Yes. mattpocock/skills is fully open-source under the MIT licence — free to install, use, and fork. The npx skills@latest installer is also free. Matt Pocock's newsletter at aihero.dev/s/skills-newsletter announces new skills as they ship.
Sources
- GitHub,
mattpocock/skillsrepository (stars, forks, created date), retrieved 2026-06-30, https://github.com/mattpocock/skills - Matt Pocock,
mattpocock/skillsREADME, February 2026, https://github.com/mattpocock/skills/blob/main/README.md - Matt Pocock,
grill-meSKILL.md, https://github.com/mattpocock/skills/blob/main/skills/productivity/grill-me/SKILL.md - Matt Pocock,
handoffSKILL.md, https://github.com/mattpocock/skills/blob/main/skills/productivity/handoff/SKILL.md - Matt Pocock,
teachSKILL.md, https://github.com/mattpocock/skills/blob/main/skills/productivity/teach/SKILL.md
About the author: Dhaval is a Claude Code power user and builder, covering AI dev tools since 2024.
Comments
Post a Comment