mattpocock skills on Remote OpenClaw

Codebase Design

Design deep modules: a lot of behaviour behind a small interface, placed at a clean seam, testable through that interface. Use this language and these principles wherever code is being designed or restructured. The aim is leverage for callers, locality for maintainers, and testability for everyone.

Diagnosing Bugs

A discipline for hard bugs. Skip phases only when explicitly justified.

Domain Modeling

Actively build and sharpen the project's domain model as you design. This is the *active* discipline — challenging terms, inventing edge-case scenarios, and writing the glossary and decisions down the moment they crystallise. (Merely *reading* CONTEXT.md for vocabulary is not this skill — that's a one-line habit any skill can do. This skill is for when you're changing the model, not just consuming it.)

Git Guardrails Claude Code

Sets up a PreToolUse hook that intercepts and blocks dangerous git commands before Claude executes them.

Grill Me

Run a /grilling session.

Grill With Docs

Run a /grilling session, using the /domain-modeling skill.

Grilling

Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.

Handoff

Write a handoff document summarising the current conversation so a fresh agent can continue the work. Save to the temporary directory of the user's OS - not the current workspace.

Implement

Implement the work described by the user in the PRD or issues.

Improve Codebase Architecture

Surface architectural friction and propose deepening opportunities — refactors that turn shallow modules into deep ones. The aim is testability and AI-navigability.

Migrate To Shoehorn

shoehorn lets you pass partial data in tests while keeping TypeScript happy. It replaces as assertions with type-safe alternatives.

Prototype

A prototype is throwaway code that answers a question. The question decides the shape.

Resolving Merge Conflicts

1. See the current state of the merge/rebase. Check git history, and the conflicting files.

Scaffold Exercises

Create exercise directory structures that pass pnpm ai-hero-cli internal lint, then commit with git commit.

Setup Matt Pocock Skills

Scaffold the per-repo configuration that the engineering skills assume:

Setup Pre Commit

- Husky pre-commit hook - lint-staged running Prettier on all staged files - Prettier config (if missing) - typecheck and test scripts in the pre-commit hook

Tdd

Core principle: Tests should verify behavior through public interfaces, not implementation details. Code can change entirely; tests shouldn't.

Teach

The user has asked you to teach them something. This is a stateful request - they intend to learn the topic over multiple sessions.

To Issues

Break a plan into independently-grabbable issues using vertical slices (tracer bullets).

To Prd

This skill takes the current conversation context and codebase understanding and produces a PRD. Do NOT interview the user — just synthesize what you already know.

Triage

Move issues on the project issue tracker through a small state machine of triage roles.

Writing Great Skills

A skill exists to wrangle determinism out of a stochastic system. Predictability — the agent taking the same _process_ every run, not producing the same output — is the root virtue; every lever below serves it.