Dual-monitor IDE workspace showing source code and agent chat, illustrating Cursor and Claude Code Agent Skills engineering workflows

In May 2026, mattpocock/skills stayed hot on GitHub Trending with star counts past the six-figure mark. Matt Pocock—creator of Total TypeScript—open-sourced the Agent Skills he had been running from a private .claude directory. This is not another chat prompt pack. It is a set of composable engineering discipline scripts that push Claude Code, Cursor, Codex, and similar tools toward align first, code second, verify third.

If you are tired of agents rewriting fifty files, leaving tests red, and still saying “done,” this article walks through problem → architecture → comparison → install workflow so you can decide whether the repo belongs in your stack. You will leave with install commands, a recommended Skill chain, boundaries versus OpenClaw and Cursor memory, and a Mac-team checklist. For contrast with session memory, see our piece on why long context does not fix cross-week collaboration—that article covers persistence; this one covers process.

1. Vibe coding lacks process, not models

“Vibe coding” became a punchline in 2026 for a reason: stronger models ship larger diffs per turn, which raises the cost of going wrong. In the repo README, Matt maps four recurring failure modes to problems software engineering has named for decades—only the accelerator is now an agent:

  • Misalignment: you believe requirements are clear; the agent implements a different interpretation; the gap surfaces only when the diff lands.
  • Verbosity: the agent does not know your domain shorthand, so twenty words of intent become a short essay—burning tokens and slowing review.
  • No feedback loop: without failing tests, type errors, or reproducible steps, the agent flies blind.
  • Entropy: generation speed doubles and design decay doubles with it; module boundaries erode until nobody wants to touch a folder.

Frameworks such as GSD, BMAD, and Spec-Kit wrap agents in heavier process shells. Matt’s critique is specific: if the workflow cannot be decomposed or adapted, debugging it feels like patching a broken compiler. The skills repo takes the opposite tack—each Skill is a short Markdown instruction file (SKILL.md) triggered by a slash command, assembled like LEGO.

That design choice matters for teams already drowning in “methodology theater.” You do not adopt a monolithic playbook; you enable the checks a senior engineer would nag you about—alignment before implementation, tests before refactors, vertical slices before horizontal marathons. The agent still chooses tokens; the Skill chooses order of operations.

In one line: mattpocock/skills does not sell a smarter model. It sells repeatable checklists written the way staff engineers actually talk.

2. What mattpocock/skills actually is

The subtitle is blunt: Skills for Real Engineers. Straight from my .claude directory. Technically, it is a skill pack collection distributed through the skills.sh ecosystem, MIT licensed, with live star counts on GitHub (well over 100k at time of writing). Skills fall into three buckets:

2.1 Engineering — daily coding

Slash commandRoleWhen to run it
/grill-me, /grill-with-docsInterrogate requirements before coding; the docs variant maintains CONTEXT.md and ADRsBefore any non-trivial feature
/tddRed–green–refactor: failing test first, then implementationBusiness logic, bug fixes
/diagnoseReproduce → minimize → hypothesize → instrument → fix → regressionPerformance, concurrency, heisenbugs
/to-prdCondense the conversation into a PRD and open a GitHub IssueDiscussion is mature but undocumented
/to-issuesSplit a PRD or plan into vertical, independently shippable issuesBefore sprint planning
/improve-codebase-architectureFind module boundaries worth deepening, using domain languagePeriodic repo hygiene (e.g. weekly)
/setup-matt-pocock-skillsConfigure issue source, triage labels, documentation pathsRequired once per repo after install

2.2 Productivity — collaboration across sessions

/caveman strips phrasing to bare directives (README cites roughly 75% token savings). /handoff compresses a session into a handover doc for the next agent or teammate. /write-a-skill scaffolds a new Skill to Matt’s conventions. These matter when sessions run long, when multiple people relay the same thread, or when inference cost is a line item.

2.3 Misc — safety and scaffolding

/git-guardrails-claude-code installs hooks that block dangerous Git operations (force-push, hard reset, and similar foot-guns). Pre-commit scaffolding and practice-directory generators sit here too—they are optional for the main chain but valuable on repos with painful Git history.

2.4 Shared language: why grill-with-docs compounds

The README contrasts plain language (“lessons are not materializing”) with domain vocabulary (“materialization cascade is failing”). Once terms land in CONTEXT.md, variable names, filenames, and follow-up prompts shorten and align. That pairs with a code knowledge graph for large repos: graphs expose structure; CONTEXT.md captures team oral contract—the words you would use in standup, not in a generic LLM prompt.

Neither replaces the other. A graph helps an agent navigate imports and ownership; CONTEXT helps it stop inventing synonyms for the same concept. Teams that skip shared vocabulary often “fix” misalignment by buying a larger context window, which is expensive and still brittle across weeks.

3. Comparison: Rules, OpenClaw, and heavy methodologies

The table below is a selection lens, not a winner-takes-all scorecard:

Dimension mattpocock/skills Cursor / IDE Rules OpenClaw skill ecosystem GSD / Spec-Kit style
Shape Installable slash Skill packs Static project rule files Gateway plugins + openclaw skills Multi-stage process templates
Strength Alignment, TDD, issue slicing, architecture sweeps Style, layout, naming conventions Multi-channel messaging, cron, webhooks Full narrative from spec to delivery
Control High — enable one Skill at a time High Medium — heavier ops surface Low–medium — process owns the flow
Mac angle Any OS; iOS/macOS CI often needs macOS runners Local IDE first Often a always-on Mac gateway Depends where you run the agent

Compared with our OpenClaw ClawHub skills and minGatewayVersion troubleshooting guide, OpenClaw answers where messages enter and how the gateway stays healthy; mattpocock/skills answers how the agent behaves like an engineer after it is in the repo. Community lists often place addyosmani/agent-skills beside Matt’s pack—the former leans /spec → /ship lifecycle; the latter leans tests and alignment. Both can live in the same repository.

If your pain is “the agent forgot last week’s decision,” Rules plus CONTEXT.md define memory boundaries; process Skills define whether this change runs through TDD. Do not expect a 200k-token window to substitute—see the long-context article linked above for why weekly work needs artifacts, not just bigger prompts.

4. 30-second install and recommended Skill workflow

The official quickstart has three steps. Run them at a real repository root (paths and flags follow upstream README):

4.1 Install

npx skills@latest add mattpocock/skills

The installer prompts for which Skills to install and which agent targets to wire (Claude Code, Cursor, Codex, and others). Always include /setup-matt-pocock-skills in the selection.

4.2 Repository setup

Inside your agent session, run:

/setup-matt-pocock-skills

Choose your issue tracker (GitHub, Linear, or local files), label vocabulary for /triage, and where CONTEXT.md and ADRs should live. Skipping setup is the most common reason /to-issues and /triage produce tickets that do not match team habits.

4.3 A copy-paste feature-development chain

  1. /grill-with-docs (or /grill-me) — continue until decision trees have no “TBD” branches.
  2. /to-prd — when consensus exists, synthesize a PRD and open an issue.
  3. /to-issues — vertical slices; avoid “frontend week, backend week” horizontal slabs.
  4. Per issue, run /tdd; when stuck, /diagnose.
  5. Before release or on a cadence (e.g. Fridays), run /improve-codebase-architecture.

This chain is deliberately boring—that is the point. Excitement in agent demos usually means skipped alignment; boredom in production usually means predictable diffs and green CI.

4.4 Wiring Apple and Mac teams

Skills are cross-platform. When the same repo also runs xcodebuild, code signing, or an OpenClaw gateway, a common split is: laptop + Cursor with Skills for application code, CI and gateways on self-hosted Mac runners or a dedicated remote Mac. For local model overflow on Apple Silicon, compare MLX versus Ollama—Skills do not pick your inference backend; they constrain how the agent edits the tree.

# Example: Skills are orthogonal to existing CI verification
xcodebuild -project MyApp.xcodeproj -scheme MyApp \
  -destination 'platform=iOS Simulator,name=iPhone 16' build

Think of Skills as the conversation contract and CI as the machine contract. Passing one does not imply the other; together they shrink the gap between “agent said done” and “main is shippable.”

5. Anti-patterns: when not to install everything

  • One-off scripts or sub-50-line edits: /grill-me adds friction; write explicit acceptance criteria instead.
  • Mature Spec-Kit pipeline already working: do not rip and replace; cherry-pick /tdd or /diagnose only.
  • No owner for CONTEXT.md: /grill-with-docs rots without a doc maintainer—assign one before enabling doc-heavy Skills.
  • Primary need is IM/Webhook automation: prioritize an OpenClaw-class gateway; this pack does not solve channel ingress.

Star velocity signals resonance, not automatic seniority. The repo iterates quickly in beta—read CHANGELOG before upgrades, especially setup and issue-template changes. A team that installs every Skill on day one often disables half of them by week three; start with the trio in the FAQ and expand when pain appears.

FAQ

How is mattpocock/skills different from Cursor Rules?

Cursor Rules are mostly static project conventions; mattpocock/skills are composable slash-command workflows (such as /grill-me and /tdd) that enforce alignment, testing, and issue breakdown step by step inside a conversation. You can use both: Rules set the floor, Skills run the process.

Do I need Claude Code to use these Skills?

No. The official skills.sh installer supports Claude Code, Cursor, Codex, and other agents. When you install, pick your target agent and each Skill is written into that tool's config directory in the format it expects.

What should I do first after installing?

Run /setup-matt-pocock-skills: configure your issue tracker (GitHub, Linear, or local files), triage label vocabulary, and where CONTEXT.md and ADRs live. Without setup, /to-issues, /triage, and related skills lack repository context.

Does it conflict with GSD, BMAD, or Spec-Kit?

Not necessarily. Matt's positioning is small, adaptable, composable skill packs—not a heavyweight framework that owns the whole pipeline. If you already write PRDs in Spec-Kit, you can still use /to-issues to slice them into vertical, independently shippable issues.

Which three Skills should I install first?

Most teams start with /grill-me (or /grill-with-docs), /tdd, and /to-issues: alignment, a code feedback loop, and task breakdown. Add /git-guardrails-claude-code if your repo has a history of risky Git operations.

Do I still need a remote Mac when running agents on a Mac?

TypeScript and frontend work often stay on the laptop; iOS builds, large-context local models, and 24/7 gateways such as OpenClaw usually need dedicated macOS. Skills govern how you collaborate; a remote Mac governs where macOS workloads run—the responsibilities are different.

Conclusion

The surge behind mattpocock/skills shows developers want more than another chat box that writes code—they want auditable, composable, teachable engineering flow. /grill-me plugs alignment leaks; /tdd and /diagnose restore feedback; /to-issues turns PRDs into vertical, shippable work. That is a practical path from vibe coding toward discipline without adopting a monolithic methodology.

  • Install: npx skills@latest add mattpocock/skills, then run /setup-matt-pocock-skills.
  • Default chain: align → PRD → slice issues → TDD per issue → periodic architecture pass.
  • OpenClaw, knowledge graphs, and remote Macs complement Skills—they do not replace them.

When your next step is hosting agent gateways or iOS CI on macOS, visit the Macstripe home page for dedicated M4 Mac Mini nodes; more OpenClaw and AI infrastructure articles are indexed on the Developer Blog.

Related reading