▶ YouTube Summaries

• YT :: https://www.youtube.com/watch?v=0oXOOlqVu5M
• Original title :: So I tried Matt's skills...

Theo spends a week installing and using skills from two published collections - Matt Pocock's skills repo (over 200k GitHub stars, all markdown) and PStack by Lauren "Potato", a React compiler contributor now at Cursor. The verdict: enormous value in both, but he is philosophically closer to PStack, and the single highest-leverage skill is unslop. His core message is that blindly copying someone else's setup is worthless - use these as reference material while building your own.

Method

He started by prompting an agent to audit his shell history across three machines, compare it against the skills in each repo, and rank the skills by fit and expected benefit, fanning out subagents to do the auditing. That produced a ranked document per repo, from which he pulled a handful into a personal fleet repo that manages skill files across all his machines.

A useful trick: to try a text-only skill you do not have to install it. Copy the markdown and paste it into the agent along with your request.

Descriptions are triggers, not descriptions

Because a skill is just markdown the model reads in full once selected, the front-matter description has exactly one job: get the right agent to pull the skill in at the right moment. He compares it to a YouTube thumbnail - not an accurate summary, a hook. It should have been called "trigger".

He also likes the explicit split between user-invoked skills (disable model invocation, triggered by slash command) and model-invoked ones. The two are fundamentally different: the former are plugins you call, the latter steer the model's default behaviour.

unslop

The standout. It edits text to remove AI patterns and add a human voice: scan for patterns, rewrite preserving meaning and tone, add soul, then self-audit by asking "what makes this obviously AI generated?"

Guidance it encodes:

• Have opinions; react to facts rather than neutrally listing pros and cons.
• Vary rhythm, allow some mess, use first person when it fits.
• Be specific: "there's something unsettling about agents churning away at 3am", not "this is concerning".
• Cut puffery ("pivotal moment", "testament to", "evolving landscape"), name-dropping without context, superficial -ing phrases (highlighting, ensuring, reflecting, showcasing), promotional language, chatbot phrases, jargon, and em-dash overuse.
• Say what it does, not how it feels: "SQL returns the exact string sent to the database", not "the database stays close at hand".
• If a sentence cannot be restated as a concise instruction, fact or number, cut it. If it could appear unchanged in another project's docs, it says nothing about this one.

The skill itself is densely and well written, which matters - models imitate good writing in their context. Theo says it has fundamentally changed his willingness to read what his agents write. Running side by side comparisons of the same model with and without the skill, the difference was immediately obvious to him.

Matt Pocock's skills

The skills/engineering directory holds ask-matt, code-review, codebase-design, diagnosing-bugs, domain-modeling, grill-with-docs, implement, improve-codebase-architecture, prototype, research, resolving-merge-conflicts, TDD, tickets, triage, wayfinder, wizard, plus productivity skills (grill-me, handoff, teach, wait-what, writing-for-agents).

• grilling :: interviews you relentlessly about a plan, mapping decisions as a tree and working the frontier in rounds. Theo pointed it at his LakeBed project and got genuinely sharp questions - who pays, what the next milestone is, whether the capsule format is a spec - and admits it exposed real mess. It offers multiple-choice example answers, which makes blasting through fast.
• diagnosing-bugs :: model-invoked, has been firing on its own and helping agents find and communicate root causes.
• wizard :: guides a human through steps only they can do (dashboard access, sudo). Theo installed it immediately.
• writing-for-agents :: instructions for writing documents agents consume; he uses it for subagent prompts. Its "context pointer" section he finds unreadable.
• wait-what :: three lines, user-invoked, restates a jargon-heavy answer plainly. Repairs one message only; the real fix is shared vocabulary built up front.
• The documented main flow is grill-with-docs, spec, tickets, implement, code-review. Theo finds this more prescriptive than his own workflows want.

Running complaint throughout: the skills are full of em-dashes, which is where his agents' em-dashes were coming from.

PStack

• unslop :: as above.
• arena :: fan out parallel attempts at the same task, read every candidate end to end, pick the strongest as base, graft the best ideas from the others in, verify. Phases tracked in a todo list so none silently vanish. Expensive - hundreds of dollars of inference.
• blast-radius :: find what a change breaks elsewhere before shipping. Complements "how" (what the code does) and "why" (why it is shaped that way). Notably instructs the agent not to trust its own thread writeup, but to isolate the one or two load-bearing facts and prove them by running code. Has already caught real problems for him.
• show-your-work :: append-only TSV decision log, one row per decision (what, why, evidence, result); a wrong call is superseded by a new row rather than edited. For autonomous or multi-phase runs reviewed later.
• bro :: restate the last message without jargon; effectively identical to Matt's wait-what.

Main drawback: several PStack skills are written specifically for Cursor. He would welcome a harness-agnostic fork.

Advice

Install unslop first so you actually want to read the output. Then have your agent audit your own history against these repos, read the markdown of any skill before installing it, keep your selections in one repo you control, and edit the files - people are needlessly afraid to open their Claude and agents directories. He jokes that the only reason he opens an editor now is to edit markdown and environment variables, and credits that shift for how much parallel agent work he can sustain.