So I tried Matt's skills...

Summary of technological concepts / product features / analysis

Two major “AI engineering skill” ecosystems on GitHub

Reviewed and personally tested two main skill ecosystems on GitHub:

• Matt’s skills (Matt Pocock)

  • Extremely popular markdown-based “skills”
  • 200k+ GitHub stars and among the top starred repos
  • Example skills highlighted:
    • “grill me”
    • “grill with docs”

• Pstack skills (Lauren / Potato)

  • Potato is a React compiler contributor now at Cursor
  • Positioned as fun but surprisingly powerful
  • Multiple skills are audited and selected for active use

Core explanation: how “skills” work (mechanics)

The core model behavior described:

• Each skill is essentially:
  • A named block
  • Containing markdown + a description/trigger
• The model:
  1. Reads the skill name/description
  2. Decides when to pull in the skill
  3. Then reads the markdown file into context
• The speaker emphasizes that skill descriptions should be treated as triggers (routing signals), not as complete, authoritative documentation of every capability.

Major evaluation theme: “Life post-slop” / “unslop”

A key standout is Potato’s “unslop” skill, which the speaker adopts quickly and uses extensively because it improves outputs by:

• Making responses more direct
• Reducing verbosity
• Improving scan-ability
• Encouraging a more human voice and removing “AI tells”
• Providing structured checks and fixes for issues like:
  • Content puffery
  • Chatbot phrases
  • Vague promotional language
  • Jargon
  • Template stiffness

The speaker also notes a downstream effect: with the skill enabled, subsequent responses become markedly more readable.

Testing methodology / workflow orchestration

Instead of installing everything:

• They use an audit approach:
  • Map their actual usage across machines
  • Compare to skill catalogs
  • Rank the best fits
• They also do hands-on evaluation by copy/pasting skill content into an agent:
  • This helps observe behavior without full installation
  • Caveat: this may not work for skills requiring scripts

“Grill with docs” / “Grill me” as structured interviewing

The two “grill” styles are described as structured questioning frameworks:

• Grill with docs

  • Relentlessly interviews the user to sharpen planning/design decisions
  • Produces documentation artifacts along the way:
    • docs
    • ADRs
    • glossary
  • Uses a design-tree style approach and front-loads structure

• Grill me (and variants)

  • Stress-tests goals/decisions
  • Forces alignment through targeted questions:
    • about users
    • boundaries
    • milestones
  • Demonstrated with an example project (“LakeBed”), showing quick structured follow-up

Skill invocation controls

Many skills include a behavior similar to “disable model invocation”:

• The model is prevented from automatically invoking certain tools/skills
• The user must explicitly trigger them (e.g., via / or $ commands)

The speaker argues this is beneficial for some skills but not others:

• Good candidates for manual triggering: skills that should not run implicitly
• Should be automatic when relevant: e.g., debugging

Additional skills featured (from both ecosystems)

Other skills the speaker highlights include:

• Teach / stateful learning
  • Maintains learning state across sessions via files in a teaching workspace
• Triage
  • Uses a state machine to move issues through stages
• Improve codebase architecture / codebase design
  • Orchestrates vocabulary-building and other skills
  • Can output artifacts like HTML reports
• Wayfinder
  • Plans large work as a map of decisions
• Prototype
  • Mock/design before committing
• Research
  • Attempts cited answers from primary sources
• Wizard
  • Creates a guide for agent steps only humans can perform (e.g., dashboard access)
  • Useful when an agent can’t complete tasks directly
• Writing for agents
  • Improves the quality of instructions/markdown written for other agents
  • The claim: agents are poor at generating good agent-to-agent instructions
• Arena
  • Runs parallel attempts (“fan out”), cross-judges, then synthesizes and verifies best ideas
  • Notes a token-burner cost
• Wait what / Restate me / stop jargon
  • Clarifies and rephrases to remove ambiguity
  • Solutions converge with “wait what”-style behavior
• Blast radius
  • Checks what else a change might break
  • Encourages running code to prove key facts
• Show your work
  • Produces a reviewable decision trail (TSV-like rows):
    • What / Why / Evidence / Result

Demonstrated example comparison: agent workspace tooling

The speaker contrasts agent/control tooling, highlighting T3 Code:

• An open-source control center for coding agents
• Desktop web + mobile (iOS/Android)
• Unifies workflows into a single interface (instead of juggling separate terminals/editor workflows)
• Supports:
  • parallel work
  • checkpointing (inspect/revert agent changes)

The argument: with one workspace interface, remote agents become practical.

How the speaker applies the skills

They integrate skills into a “fleet” repo:

• Manages skill files across multiple machines
• Recommended main flow:
  • Grill with docs → Spec → Cut into tickets → Implement → Code review
• Orchestration skills referenced:
  • Shaping, Wayfinder, Prototype, Research
• Ongoing curation practices:
  • Keep skills that match real workflows
  • Avoid installing hundreds blindly
  • Edit markdown skill files directly
  • Maintain groups (e.g., Pstack vs Matt Pocock skills) and turn them on/off

---

Key reviews / guides / tutorials highlighted

• Guide/recommendation: Don’t blindly copy others’ setups; treat them as references and build a personalized system.
• Tutorial-like method: Audit your own usage history against skill catalogs, rank fit, then install only selected parts.
• Hands-on evaluation tip: Test skills quickly by copy/paste of markdown into an agent instead of installing first.
• Best-first skill recommendation: Start with “unslop” because it improves readability and increases trust/consumption of agent outputs.
• Workflow template emphasized: Grill with docs → spec → tickets → implementation → code review
• Operational practice: Manage skills in a centralized repo (the “fleet” approach) and sync across devices.

---

Main speakers / sources

• Speaker/primary source: the YouTube narrator (who tested and discussed the skills)
• Referenced creators:
  • Matt Pocock (e.g., “Matt’s skills”, “grill me”, “grill with docs”)
  • Lauren / Potato (e.g., “Pstack” / “Potato skills”, including “unslop”)
• Other referenced projects/contexts:
  • T3 Code
  • Depot CI (mentioned as a sponsor)
  • Cursor (where Potato is now)