All cardsWhich skill pack, when
Which skill pack, when
Three people have packaged how they build software into skills for coding agents. Rob Shocks has used all three and says when he reaches for each. The short of it: Pocock when the idea is fuzzy, Addy when a team ships to production, pstack when it gets gnarly. And most days, far less than any of them.
Jump to the ceremony ladder, what do I use for X, or try it yourself.
The video
13 minutes, posted Oct 7, 2026, by Rob Shocks (@robshocks) on his Switch Dimension channel. The chapter list in the description doesn't match the video, so these chapters are ours. Every timestamp opens the video at that moment.
- 0:00 The big three skill packs
- 0:46 Who Addy Osmani is
- 1:24 Addy's six stages, six commands
- 2:27 /build auto, /constraints, /webperf, /code-simplify
- 3:21 25 skills, 4 reviewer personas
- 3:32 Inside a skill: the excuses table
- 4:05 Sponsor read: Neon (until 5:08)
- 5:12 Doubt-driven development
- 5:39 Old friends: Hyrum, Beyoncé, Chesterton
- 6:16 Three packs, three questions
- 7:45 When he reaches for each
- 8:51 They overlap, and that's fine
- 9:11 You don't need all of this
- 9:59 Ceremony should match stakes
- 10:52 The cost of more skills
- 11:03 It's just good practice
- 11:50 Not a religion: build your own
- 12:29 His course and the outro
Ten signals
The whole video in ten boxes. Each links to the part of this page that explains it.
- 016:16
Three packs, three questions
Pocock asks: do we agree on what we're building? Addy asks: did we follow the whole process? pstack asks: can you prove it works?
How - 027:57
Fuzzy idea? Start with Pocock
When you're not sure what you want, the agent should question you before it writes anything. grill-me is the one skill Rob would install first.
How - 038:10
Team and production? Addy
The full life cycle, from spec to ship, with a check at every stage. Everyone on the team recognizes the steps.
How - 048:27
Gnarly? pstack
A bug you can't reproduce, a migration, an agent running overnight that you need to trust in the morning. pstack works best in Cursor.
How - 059:59
Ceremony should match stakes
A button colour needs no plan. A small feature gets a quick grill and tests. A big one gets a spec. Production, security and anything you can't undo get the full review.
How - 069:11
You don't need all of this
Every skill you install is one more thing the agent weighs, and one more that can fire when you didn't want it. More skills doesn't mean a smarter agent.
How - 073:45
Write the excuses down
Addy's skills list the excuses an agent gives to skip a step, like "too simple to test", each with the answer next to it.
How - 085:12
Doubt during the build
For any big decision, a fresh agent gets one job: prove it wrong. Review happens while you build, not only at the end.
How - 099:11
Prune your AGENTS.md
Models are strong now. Cut the lines that tell the agent things it already does. Skills are how you like to work, not lessons.
How - 1011:50
A textbook, not a religion
All three are old engineering ideas in a form an agent can follow. Read them, take what works, and fix your own skill every time the agent slips.
How
Words on this page
Eighteen terms, in plain words. Skip this if you already use skills with a coding agent.
- Skill
- A Markdown file of instructions an agent loads when the job matches. It tells the agent how to do one kind of work.
- Skill pack
- A set of skills from one person, installed together. This page compares three.
- Slash command
- A short word you type, like /spec, that starts a skill on purpose instead of waiting for the agent to pick it.
- Auto-trigger
- When the agent starts a skill on its own because your words matched its description. Handy, until it fires on a tiny job.
- Context window
- Everything the agent can hold in mind at once. Every installed skill takes a little of it.
- Ceremony
- The steps around the code: specs, plans, reviews, sign-offs. Rob's rule: the bigger the risk, the more ceremony.
- SDLC
- Software development life cycle. The classic order: decide what to build, plan, build, test, review, ship.
- Spec / PRD
- A written description of what to build and how you'll know it's done, before any code. PRD means product requirements document.
- Grilling
- The agent interviews you, one question at a time, until it understands what you actually want.
- TDD
- Test-driven development. Write a test that fails, write code until it passes, repeat.
- Vertical slice
- A thin piece of a feature that works end to end, built and tested before the next piece.
- ADR
- Architecture decision record. A short note saying what you decided and why, so nobody has to guess later.
- Persona
- A reviewer role the agent plays, like security auditor or test engineer, each with its own checklist.
- Arena / swarm
- pstack's ways to run several agents at once: an arena tries the same task several ways, a swarm splits work across workers.
- Anti-rationalization table
- Addy's list of excuses an agent makes to skip a step, each with a rebuttal.
- AGENTS.md
- A file in your project the agent reads every session: commands, rules, things to never touch. CLAUDE.md is the same idea.
- Greenfield / brownfield
- A brand-new project versus an existing one with years of code and habits.
- Harness
- Everything wrapped around the model: the agent app, its tools, your rules files and skills.
Three packs, three questions
Each pack answers a different question and puts its weight at a different moment. The bars are Rob's slide: before the code, while building, after the code. 6:16
Small skills you pick up one at a time. Most of the effort goes in before any code: the agent questions you, writes down the project's words and decisions, then turns that into a spec and tickets. He is openly against big frameworks.
Rob reaches for it when
- Fuzzy requirements
- Long-lived codebase
- You want control
- Size
- About 30 skills you type yourself
- Runs in
- Claude Code first, others through the skills installer
- Built on
- The Pragmatic Programmer and Domain-Driven Design
Install, from the README
npx skills@latest add mattpocock/skills
Or in Claude Code: /plugin install mattpocock-skills. Then run /setup-matt-pocock-skills once per repo.
Addy Osmani, long-time Google engineering lead7:23
Addy Osmani's agent-skills
“Did we follow the whole process?”
The classic software life cycle, done by an agent: define, plan, build, verify, review, ship. One command per stage, a check at every stage, and reviewer personas at the end. No new vocabulary to learn.
Rob reaches for it when
- Teams
- Production
- Predictable process
- Quality gates built in
- Size
- 25 skills, 9 commands, 4 reviewer personas
- Runs in
- Claude Code, Cursor, Codex, Gemini CLI and 70+ agents
- Built on
- Software Engineering at Google
Install, from the README
npx skills add addyosmani/agent-skills
Or in Claude Code: /plugin marketplace add addyosmani/agent-skills, then /plugin install agent-skills@addy-agent-skills.
No planning skills on purpose: her line is that the best spec is the code. The weight is on investigating, proving the change works with real evidence, and having several models try to break it.
Rob reaches for it when
- Gnarly bugs
- Migrations
- Overnight runs
- Multi-model in Cursor
- Size
- About 28 skills, one main mode with 23 playbooks
- Runs in
- Cursor plugin, with any model Cursor offers
- Built on
- Years of React work at Meta
Install, from the README
/add-plugin pstack
In Cursor. Then /setup-pstack to pick models, and /poteto-mode for any task that needs rigor.
Also named
- Superpowers, BMAD, spec-kitOlder spec-driven frameworks. Rob says Addy's pack will feel familiar if you've used them; Pocock thinks they take control away from you. Our Superpowers page.
- skills CLI The
npx skills addinstaller from Vercel Labs. Copies skill files into your project for most coding agents. Add--skill nameto take just one. - Claude Code, Cursor, CodexThe coding agents these packs plug into. Pocock leans Claude Code, pstack is a Cursor plugin, Addy's runs nearly anywhere.
The ceremony ladder
Rob's rule: the ceremony should match the stakes. Four rungs from his slide, plus two lanes beside them for gnarly work and for when the agent slips. Click a rung to see what to type in each pack, or press Start and follow one week. 9:59
The ladder · higher stakes, more ceremony
Beside the ladder
Follow one week of work
Six jobs from one made-up week on a notes app. Watch the ladder light up: the same person uses no skill on Monday and the full review on Friday.
Rung 2 of 4
Watch at 10:14Small feature
Like: A search box on a list page, an export button, a "remember me" checkbox.
What Rob runs
- /grill-me
- TDD
What to type, by pack
- Pococklead pick
/grill-me → /tddThe interview, then red-green-refactor one slice at a time. - Addy
interview-me → /testAddy's own docs say a small change can go straight to /test and /review. - pstack
/tddFailing test first, then the fix. Best when there's a cheap local test.
Skip
A full spec and a ticket breakdown. If the grill takes longer than the build, it's a tweak.
Watch out
Ask for one question at a time. A wall of twenty questions gets skimmed and answered badly.
The rungs and what Rob runs on each are from his slide. The commands for each pack come from their READMEs, and the week is ours.
What do I use for X?
Eighteen jobs, the strongest skill for each, and the others that also do it. Pick the pack you already have to see what it covers and what to borrow. “Rob names this” marks jobs he talks about; the rest is ours, from the READMEs.
When
The pack I already have
- Before code · Rob names thisI want to figure out what I actually want
Rob's first install. The agent interviews you, one question at a time, until every branch of the idea is settled.
- Before codeI want to write down my project's words and decisions
The grill, plus it keeps a GLOSSARY.md and decision records up to date as you talk.
- Before code · Rob names thisI want to write a proper spec before any code
- Before code · Rob names thisI want to set a quality bar the agent can't quietly skip
Interviews you for your standards, writes CONSTRAINTS.md, and flags agents that silence checks to get green.
- Before codeI want to break a big feature into small tasks
Small tasks, each with a way to check it's done, in the right order.
- Before codeI want to understand code I didn't write
How walks through a part of the code. Why digs up the reason it was built that way. Teach explains it diagram by diagram.
- While buildingI want to build it test-first
All three have it. Use whichever you already installed.
- While building · Rob names thisI want to run a whole approved plan without me stepping in
You approve once. Every task is still test-first and committed on its own, and it stops on a failure. Rob calls this the right way to do autonomy.
- While building · Rob names thisI want to leave it running overnight and trust it in the morningpstack/poteto-mode
Its overnight and autopilot playbooks are built to land work while you sleep, with the proof attached.
- While building · Rob names thisI want to check a big decision before I build on it
A fresh agent sees only the work and the goal, never your reasoning, and its one job is to find what's wrong.
- While building · Rob names thisI want to try several answers at once and keep the best
Several attempts at the same job in parallel, then the best parts of each.
- After code · Rob names thisI want to fix a bug I can't reproduce
Rob's first pstack case. Its bug-fix playbook won't call it fixed without evidence from the running app.
- After codeI want to review the change before it merges
Five angles, labels for what blocks a merge and what doesn't, and a size limit of about 100 lines per change.
- After code · Rob names thisI want to check it for security holes
The common attack list, login patterns, secrets and dependency checks, plus a security auditor persona. Only Addy's pack covers this.
- After code · Rob names thisI want to find out why the page is slow
Measure first, then fix. Written by the person who led Chrome's web performance work.
- After code · Rob names thisI want to tidy code that works but nobody wants to touch
Simpler, same behavior, and it must find out why odd code is there before it removes it.
- After codeI want to prove the app really works, not just the tests
Writes a skill for your project that drives the real app and checks each feature.
- After code · Rob names thisI want to ship it to production safelyAddy/ship
Checklists, staged rollout, a way back, and four reviewer personas in parallel before go or no-go.
Skills to start with
Seven skills worth knowing first: the ones Rob singles out, plus each pack's front door. The full lists are on our Pocock page, our pstack page and below for Addy.
When: Before any feature you can't explain in two lines. Rob's install-first pick.
What it does, in order
- Asks one question at a time, each with its own suggested answer
- Reads the code instead of asking when the answer is there
- Walks every branch of the idea in order
- Won't move on until you both agree
Watch out: It's for agreeing, not building. When it's done, ask for the build or hand off to /to-spec.
What you type
/grill-me I want to add a search box to the notes page.
PocockSKILL.md
grill-with-docs
The same grill, plus it writes your project's words and decisions to files.
When: A codebase you'll live with for years, where the same words should mean the same thing.
What it does, in order
- Grills you like grill-me
- Challenges fuzzy terms against GLOSSARY.md
- Records decisions as short ADRs as you go
Watch out: Run /setup-matt-pocock-skills once first so it knows where docs live.
What you type
/grill-with-docs
When: You have a spec, the plan looks right, and you don't want to press go twenty times.
What it does, in order
- Makes the plan from your spec
- Waits for your one approval
- Builds each task test-first
- Commits each task on its own
- Stops on a failure or a risky step
Watch out: It skips you between tasks, not the checks. Still look at the result of each phase.
What you type
/build auto
AddySKILL.md
doubt-driven-development
A fresh agent tries to prove an important decision wrong while you're still building.
When: Production, security, anything you can't undo, or code you don't know well.
What it does, in order
- Claim: say the decision in two or three lines
- Extract: just the code and the goal, no reasoning
- Doubt: a fresh-context reviewer looks for what's wrong
- Reconcile: sort each finding, fix the real ones
- Stop: when findings are trivial, or after three rounds
Watch out: Don't hand the reviewer your conclusion. If it sees your reasoning, it tends to agree with you.
What you type
Use doubt-driven-development on the new permission check.
When: Nothing is written down about what "good" means here, or the agent writes more than anyone reads.
What it does, in order
- Interviews you with sensible default limits
- Writes CONSTRAINTS.md
- Puts each check where it's cheapest to run
- Catches agents that turn off checks or skip tests
Watch out: Keep the file short. A bar nobody can meet gets ignored.
What you type
/constraints
pstackSKILL.md
/poteto-mode
pstack's front door. Reads your task, picks one of 23 playbooks and runs the other skills as needed.
When: Any non-trivial task in Cursor, and always for bugs, migrations and overnight runs.
What it does, in order
- Matches the task to a playbook
- Copies the playbook's steps into a to-do list
- Calls how, why, architect, arena, tdd and the rest as steps need them
- Hands back evidence, not "the build passed"
Watch out: It's heavy on purpose. Rob: overkill for small work.
What you type
/poteto-mode this list scrolls wrong every few seconds. repro first, then fix and verify.
pstackSKILL.md
/interrogate
Several models try to break your change, one with a strict code-quality eye.
When: Before merging something that matters, especially if one model wrote it.
What it does, in order
- Gives the diff to different models
- Each hunts for problems
- Brings back one list
Watch out: Needs more than one model set up. Run /setup-pstack first.
What you type
/interrogate review this pr.
Addy's pack, opened up
Addy Osmani led Chrome's developer experience and web performance work at Google and wrote Learning JavaScript Design Patterns. Rob says he has since joined Anthropic. His pack passed 100,000 GitHub stars and has no page of its own here yet, so this is the full tour. 0:46
Six stages, six commands 1:24
- 1Define/specWrite what you're building and how you'll know it's done.
- 2Plan/planSmall tasks, each with a way to check it.
- 3Build/buildOne thin slice at a time: build, test, commit.
- 4Verify/testTests are the proof.
- 5Review/reviewFive-angle review before merge.
- 6Ship/shipChecklists, staged rollout, personas, go or no-go.
Plus three more commands: /constraints (set the quality bar once), /webperf (web performance audit), /code-simplify (make working code easier to read). And /build auto, which Rob likes most: approve the plan once, and it builds every task without you stepping in between. 2:27
Inside every skill: the excuses table 3:45
From the test-driven-development skill, shortened. Rob shows the first two. Every one of the 25 skills has a table like this, plus red flags and the evidence it needs before it calls a step done.
Doubt-driven development 5:12
- 1ClaimName the decision in two or three lines
- 2ExtractJust the code and the goal, no reasoning
- 3DoubtA fresh agent, told to find what's wrong
- 4ReconcileSort every finding against the code
- 5StopTrivial findings, three rounds, or you say so
For any decision that matters, a second agent with a fresh context gets one job: doubt it. Rob's point: review during the build, not only at the end. The skill lets you loop back up to three times.
Old friends in the skills 5:39
Hyrum's Law
Every behavior of your API that people can see, someone will end up depending on.
api-and-interface-designThe Beyoncé Rule
If you liked it, you should have put a test on it.
test-driven-developmentChesterton's Fence
Don't take down the fence until you know why it's there.
code-simplification
Four reviewer personas 3:21
- Code reviewerA senior staff engineer: would they approve this?
- Test engineerTest plan, coverage, prove it works.
- Security auditorThreats, holes, the common attack list.
- Web performance auditorLoading speed and Core Web Vitals.
/ship runs all four at once and merges them into go or no-go.
All 25 skills, by stage · from the README
Define
- interview-me One question at a time until it knows what you want
- idea-refine Turn a vague idea into concrete options
- spec-driven-development A spec before any code
- constraint-driven-development Your quality bar, written down and enforced
Plan
- planning-and-task-breakdown Small tasks with checks, in order
Build
- incremental-implementation Thin slices, each tested and committed
- test-driven-development Red, green, refactor
- context-engineering Give the agent the right files and rules
- source-driven-development Check official docs, cite them
- doubt-driven-development A fresh agent tries to prove you wrong
- frontend-ui-engineering Components, design systems, accessibility
- api-and-interface-design Contract first, Hyrum's Law
Verify
- browser-testing-with-devtools Look at the real page through Chrome DevTools
- debugging-and-error-recovery Reproduce, localize, reduce, fix, guard
Review
- code-review-and-quality Five angles, about 100 lines per change
- code-simplification Simpler code, same behavior
- security-and-hardening Common attacks, secrets, dependencies
- performance-optimization Measure first, then fix
Ship
- git-workflow-and-versioning Small commits on one main branch
- ci-cd-and-automation Checks that run on every push
- deprecation-and-migration Code is a liability: remove what's dead
- documentation-and-adrs Write down why
- observability-and-instrumentation Logs and metrics as you build
- shipping-and-launch Checklists, staged rollout, rollback
Router
- using-agent-skills Picks which skill fits the job
You don't need all of this
Rob's main opinion: running every skill on every project is massive overkill. Models are strong now. Skills are more about how you like to work than teaching the agent anything new. 9:11
Too much · his slide
9:47A PRD for a button colour?
- Security audit
- Five-axis code review
- Task breakdown
- PRD
- Change button colour
Right-sized
Change the button and look at it
- Change button colour
- Refresh. Look. Move on.
Save the stack on the left for the top rung: production, security, things you can't undo.
Rob
9:41It fills the agent's head
Long skill files and too many of them bloat the context window and confuse the agent.
Rob
10:52It fires when you didn't ask
Every installed skill is something the agent has to consider, and some will start on their own on the wrong job.
Addy's comparison doc
ReadTwo routers fight
Run two packs as your main router and they clash over names like /tdd and pull in different test habits. Pick one; borrow single skills from the others.
His own setup: light, medium, heavy 7:45
Rob keeps three versions of his own skill setup and mixes skills from all three packs. He shows the three bars; what goes in each is our reading of his ladder.
Addy agrees · his adoption guide 10:40
New project
Run the whole life cycle from the first feature. Tests, small commits, security and decision notes stay on from day one.
Existing project
Start with skills that read and protect: write the rules file, review incoming changes, fix bugs carefully. Add tests where you plan to change things. New features get the full treatment later.
The guide's own warning: loading all 25 skills into every session wastes context. Read the guide.
Prune your AGENTS.md
Rob's advice: go through your AGENTS.md and your skills and cut them back. You'll be surprised how much the model already does. The six lines are the example file on his screen; which ones to keep is our call. 9:20
- Keep
Use pnpm, not npmThe agent can't guess this. It's a fact about your project. - Cut
You are a senior software engineerRole-play adds nothing for today's models. - Keep
Run the tests before committingKeep it, or better, make a hook or CI enforce it so it can't be skipped. - Cut
Always think step by stepModels already reason. How hard they think is a setting, not a sentence. - Move
Write a PRD before every changeThat's a spec for every button colour. Move it to a skill you call on big work. - Keep
Never edit files in /generatedA real landmine. Exactly what this file is for.
FakeNerd starter · a pruned AGENTS.md with the ladder
# AGENTS.md - Use pnpm, not npm. - Run the tests before committing. - Never edit files in /generated. They're rebuilt from src/schema. - Big or risky work: ask me which rung it is before you start (see below). ## Match the ceremony to the stakes - Small tweak: just do it. I'll check it. - Small feature: ask me questions first, one at a time, then build test-first. - Big or fuzzy feature: write a short spec and a plan in phases. Stop after each phase. - Production, security, or can't be undone: full review, and have a fresh agent try to prove it wrong.
It's just good practice
Rob's real lesson: learning these skills is learning good software engineering. None of it is new. Here are his six practices, and where each pack keeps them. 11:03
| Practice | Pocock | Addy | pstack |
|---|---|---|---|
| Test-driven development | /tdd | test-driven-development | /tdd |
| Small vertical slices | /to-tickets | incremental-implementation | stacked PRs |
| Agree on requirements first | /grill-me | /spec | /architect |
| Write down why you decided | ADRs in grill-with-docs | documentation-and-adrs | /show-me-your-work |
| Know why the fence is there | /improve-codebase-architecture | code-simplification | /why |
| Prove it on the real thing | /pr (before-and-after proof) | browser-testing-with-devtools | /create-verification-skill |
The table is one row per practice on Rob's slide; the skill in each column is ours, from the READMEs.
Where the skills came from 11:32
- The Pragmatic Programmer and Domain-Driven DesignPocock
- Software Engineering at GoogleAddy
- Years of React work at Metapstack
Same old ideas, in a format an agent can follow. Rob's advice: treat the packs like a textbook, not a religion. Install them, read them, keep what works, and build your own on top.
Try it, smallest version first
Seven steps, cheapest first. All free beyond the agent you already pay for. You can stop after step 2 and already have Rob's best single skill.
- 01
Install one skill, not a pack
Rob's first pick. In a cloud agent like Cloudroom or bb, ask the agent to run this in your repo. On your laptop, run it yourself in the project folder.
mattpocock/skillsCommand
npx skills@latest add mattpocock/skills --skill grill-me
- 02
Use it on your next small feature
Type /grill-me and one sentence about the feature. Answer its questions. Then ask it to build test-first.
How grill-me works - 03
Add the ceremony ladder to your AGENTS.md
Paste the four rungs from the pruned file below. Now the agent asks which rung a job is before it starts.
The pruned AGENTS.md - 04
Cut what the model already does
Go line by line through your AGENTS.md. Keep facts about your project. Cut the pep talks.
Keep, cut or move - 05
Add one review skill before you ship anything real
Addy's five-angle review, on its own. A single-skill install doesn't bring his shared checklists; the skill still works.
addyosmani/agent-skillsCommand
npx skills add addyosmani/agent-skills --skill code-review-and-quality
- 06
When the agent repeats a mistake, write your own skill
Use the starter below. This is how all three packs were built.
The starter - 07
Only for a gnarly day: pstack in Cursor
A bug nobody can reproduce, a migration, an overnight run. Install, pick your models, then start with /poteto-mode.
pstack on GitHubCommand
/add-plugin pstack
FakeNerd starter · which rung is this?
Before you start, tell me which rung this job is and what you'll skip: 1. Small tweak: just do it, I'll check it. 2. Small feature: ask me questions one at a time, then build test-first. 3. Big or fuzzy feature: short spec, plan in phases, stop after each phase. 4. Production, security or can't be undone: full review, and a fresh agent tries to prove it wrong. The job: [describe it in one or two lines]
FakeNerd starter · turn a repeated mistake into a skill
You just [describe the mistake, e.g. called a task done while a test was failing]. This is the second time. Write it into a skill so it doesn't happen again: - If a skill for this kind of work exists in .claude/skills (or .agents/skills), add one rule to it. - If not, create a small SKILL.md with a name, a one-line "use when" description, and the rule. - Add one line to its excuses table: the excuse you'd give to skip this, and why it's wrong. - Keep it under 30 lines. Show me the diff before you save.
- Both starters are ours, built from what Rob says. He doesn't show a prompt.
- The rung starter works with no pack installed at all. That's the point.
Skill packs on this site
Addy's pack is new here. The others each have their own page. Run one as your main pack and borrow single skills from the rest; two running at once fight over names and habits.
| Pack | Its question | Ceremony | Best for |
|---|---|---|---|
| Addy's agent-skills | Did we follow the whole process? | Medium to heavy, a check at every stage | Teams, production, security |
| Pocock Skills | Do we agree? | Light, you call each step | Requirements, long-lived code |
| Superpowers | Can it run the whole loop alone? | Heavy, fires on its own | Big hand-offs you walk away from |
| Compound Engineering | Does each job make the next one easier? | Medium | Turning lessons into reusable notes |
| pstack | Can you prove it works? | Heavy, by design | Gnarly bugs, overnight runs, Cursor |
Addy keeps an honest comparison of his pack, Superpowers and Pocock's, with its own when-to-use list. It's worth reading next to Rob's.
FakeNerd's take
The ladder beats the packs
Rob's four rungs work with any pack, or none. Most days most people live on the bottom two. That's where to start, not with 25 skills.
One skill first, then earn the next
Install grill-me. Add a review skill before you ship something real. Bring out pstack on the day a bug beats you. Add skills when a job asks for them.
Read Addy even if you never install it
The excuses tables, the adoption guide and the comparison doc are free lessons in how good engineers think, and they're honest about the other packs.
No test in this one
The description promises a head-to-head; the video doesn't have one. The picks are Rob's judgment from using them, which is useful, but it isn't a measurement.
Attribution
- Rob Shocks, “Pocock vs Pstack vs Osmani: Which Skill Pack Wins?” (Switch Dimension, posted Oct 7, 2026). The three questions, the reach-for lists, the ceremony ladder, the practices and the opinions are his, in our words. The slides are read from the screen. Sponsored by Neon, which isn't part of this page. The video ends with a plug for his paid course.
- addyosmani/agent-skills by Addy Osmani with Federico Bartoli and Joan León, mattpocock/skills by Matt Pocock, and pstack by Lauren Tan, all MIT. Skill names, commands, install lines and counts are from their READMEs on Oct 7, 2026, summarized. The excuses rows are shortened from Addy's test-driven-development skill.
- Claims about people's jobs (Addy joining Anthropic) are Rob's, not checked by us.
- The job picker, the week walkthrough, the per-pack commands on each rung, the AGENTS.md calls, both starters and the takes are FakeNerd's. Not sponsored by anyone on this page.