Explore

Resolve an in-progress Git merge or rebase conflict while preserving the relevant intent of both sides. Use when conflict markers or an interrupted merge/rebase need investigation and resolution.

Investigate questions using high-trust primary sources and traceable citations. Use when the user asks for research, current documentation or API facts, source verification, or evidence-backed comparison.

Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.

Analyze a codebase for high-leverage architectural improvements and explain evidence, tradeoffs, and next steps. Use explicitly for architecture audits or deep-module refactoring opportunities.

Implement work from a spec, ticket, or agreed conversation. Use explicitly when the user wants an existing plan carried through to working code.

Compact the current conversation into a handoff document for another agent to pick up.

Grill the user relentlessly about a plan, decision, or idea. Use when the user wants to stress-test their thinking, or uses any 'grill' trigger phrases.

A relentless interview to sharpen a plan or design, which also creates docs (ADR's and glossary) as we go.

A relentless interview to sharpen a plan or design.

Clarify domain concepts, language, boundaries, and durable architectural decisions. Use when terminology is ambiguous, the user is shaping a domain model, or a design depends on resolving what concepts mean.

Design or improve module interfaces using deep-module heuristics. Use when deciding where a seam belongs, reducing caller-facing complexity, improving testability or navigability, or comparing module designs.

Review a Git diff against repository standards and its originating requirements. Use for pull requests, branches, work-in-progress changes, or changes since a commit, tag, or merge-base.

Recommend the smallest Matt Pocock skill or short skill sequence that fits the user's current goal.

UI/UX design intelligence expert for web and mobile applications. Use when designing interfaces, selecting color palettes, typography, visual styles, building landing pages, dashboards, or reviewing code for UX issues. Covers 50+ design styles, 97 color palettes, 57 font pairings, 99 UX guidelines, 25 chart types across 9 tech stacks (React, Next.js, Vue, Svelte, SwiftUI, React Native, Flutter, Tailwind, shadcn/ui).

GOD MODE deep research skill. Multi-phase autonomous research loop: query decomposition → multi-source crawling → claim cross-referencing → conflict resolution → structured synthesis with inline citations. Use for any question that demands depth, sourcing, and verifiable accuracy.

Forces the laziest solution that actually works, simplest, shortest, most minimal. Channels a senior dev who has seen everything: question whether the task needs to exist at all (YAGNI), reach for the standard library before custom code, native platform features before dependencies, one line before fifty. Supports intensity levels: lite, full (default), ultra. Use whenever the user says "ponytail", "be lazy", "lazy mode", "simplest solution", "minimal solution", "yagni", "do less", or "shortest path", and whenever they complain about over-engineering, bloat, boilerplate, or unnecessary dependencies.

Persistent, token-efficient project memory. When ON, maintains a `.shob/memory/` folder of structured `.md` files so the full context of the project is NEVER lost across responses, sessions, or context compaction. Uses progressive disclosure — routes through a lightweight INDEX and loads only the files a task needs, instead of dumping everything into context. Read memory at the START of every response, write it back at the END. Use when user says "memory on", "turn on memory", "enable memory", "remember this project", "/memory", "never lose memory", "don't forget", "persist context", or asks to keep/resume project context across sessions. Stays active until "memory off".

Grill me about specs for the workflows I want to build, within this workspace.

Survey any codebase as a senior advisor and produce prioritized, self-contained implementation plans for OTHER models/agents to execute. Strictly read-only on source code — never implements, fixes, or refactors anything itself. Use when asked to audit a codebase, find improvement opportunities (bugs, security, performance, test coverage, tech debt, migrations, DX), suggest features or where to take the project next (roadmap, product direction), or generate handoff plans for another agent to implement.

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications (examples include websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished code and UI design that avoids generic AI aesthetics.

Ultra-compressed communication mode. Cuts token usage ~75% by speaking like caveman while keeping full technical accuracy. Supports intensity levels: lite, full (default), ultra, wenyan-lite, wenyan-full, wenyan-ultra. Use when user says "caveman mode", "talk like caveman", "use caveman", "less tokens", "be brief", or invokes /caveman. Also auto-triggers when token efficiency is requested.

You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.

Build AI agents on Cloudflare Workers using the Agents SDK. Load when creating stateful agents, durable workflows, real-time WebSocket apps, scheduled tasks, MCP servers, or chat applications. Covers Agent class, state management, callable RPC, Workflows integration, and React hooks.

Claude Mind - Search and manage Claude's persistent memory stored in a single portable .mv2 file

Set up Claude Code hooks to block dangerous git commands (push, reset --hard, clean, branch -D, etc.) before they execute. Use when user wants to prevent destructive git operations, add git safety hooks, or block git push/reset in Claude Code.

Disciplined diagnosis loop for hard bugs and performance regressions. Reproduce → minimise → hypothesise → instrument → fix → regression-test. Use when user says "diagnose this" / "debug this", reports a bug, says something is broken/throwing/failing, or describes a performance regression.

Diagnose hard bugs and performance regressions with reproducible evidence, focused hypotheses, and proportional instrumentation. Use when something is broken, failing, throwing, intermittently wrong, or unexpectedly slow.

Use when reviewing rendered HTML, interactive components, or design-system patterns related to Ensure logical focus order. Check native semantics first, then inspect keyboard behavior, focus flow, accessible names, and screen-reader output where relevant.

Use when reviewing scripts, client components, bundles, or runtime behavior related to Implement proper error handling. Inspect both source code and the browser execution path so fixes target the real bottleneck or bug.

Audits queries, transactions, consistency and persistence resource lifetimes; read-only.

Audits implemented architecture boundaries, dependencies and ownership; not target design or plan review.

Audits existing tests for risk coverage, reliable oracles and maintenance value; does not edit tests.

Audits cross-cutting codebase health, security and maintainability; not a single-change review or specialist audit.

Audits documentation and comments for trust, coverage, consistency and freshness; read-only.

Reviews a completed change for acceptance, regressions and release risk; read-only, not a whole-codebase audit.

Builds, updates or retires scoped acceptance tests and verifies execution; does not repair product code.

Designs user flows, interaction states and mockups for a defined product scope; does not implement UI code.

Defines product requirements, business rules and acceptance criteria for a committed intent; edits product docs only.

Evaluates new product opportunities through demand, channels and economics before committing to build.

Evaluates observed product outcomes against a prior hypothesis; does not run experiments or change user treatment.

Diagnoses incidents from operational evidence and proposes recovery; does not change live systems.

Compares tools or implementations through controlled benchmarks and independent correctness checks.

Profiles and improves a measured performance bottleneck; retains only verified improvements.

Modernizes a bounded capability to reduce demonstrated maintenance cost; not routine upgrades or performance tuning.

Upgrades dependencies in reversible batches with version-specific compatibility and regression checks.

Implements one scoped product feature or fix using existing contracts; not upgrades, performance tuning or establishing cross-cutting technical foundations.

Prepares and verifies schema migrations, database roles and isolated recovery or test resources; not query tuning or runtime mutation orchestration.

Implements transactions, idempotency and interrupted-operation recovery; not schema migration or a mandatory background-job platform.

Implements structured diagnostics, correlation and justified metrics or traces; not incident investigation or a mandatory telemetry platform.

Implements safe error boundaries, cancellation and user recovery contracts; not telemetry pipelines or durable retry machinery.

Implements permissions and tenant or owner scoped resource access while preserving approved grants; not authentication or role redesign.

Implements or repairs identity verification and session or credential lifecycle; not operation permissions, resource access policy or a new identity provider by default.

Establishes configuration ownership, validation, secret boundaries and environment isolation; not credential identity policy or live deployment.

Builds, hardens or reviews container images and local runtime packaging with startup and shutdown evidence; not remote deployment or host administration.

Creates project technical rules and recurring local procedures from the actual stack; edits guidance only, not architecture targets or application code.

Drafts or publishes authorized, fact-checked GitHub Discussions announcements; does not create releases.

Prepares CI/CD and remote infrastructure, then executes authorized rollouts with health and recovery checks; not standalone local container packaging.

Prepares and publishes an explicitly requested tagged GitHub release; does not deploy applications.

Commits, pushes and remotely verifies authorized repository changes; does not create releases.

Reviews a concrete implementation plan for missing decisions, feasibility and risk before execution; read-only.