vinvcn/mattpocock-skills-zh-cn
29 skills9.1k installs14.2k starsGitHub
Install
npx skills add https://github.com/vinvcn/mattpocock-skills-zh-cnSkills in this repo
1Grill MeGrill Me is a journey-wide agent skill (Matt Pocock-style, zh-CN) that turns vague plans into tested commitments through relentless Socratic interviewing. A solo builder invokes it when they want to be challenged on architecture, UX, or rollout assumptions—not comfort validation. The agent asks a single question at a time, offers its recommended answer, and when facts live in the repository it inspects the codebase instead of guessing. Along a design or decision tree it resolves one branch before the next, so dependencies surface early. It fits Idea research debates, Validate scoping, Build PM checkpoints, and Ship launch prep equally well whenever a written plan or design exists and you need adversarial clarity before coding accelerates.556installs2Grill With Docsgrill-with-docs (as packaged in this repo slice) equips agents to offer and write lightweight Architecture Decision Records in Chinese-oriented Matt Pocock-style workflows. It defines where ADRs live (docs/adr/), how to number them, a minimal one-paragraph template, and optional status metadata. The decision gate is strict: only document choices that are costly to reverse, confusing without context, and the result of genuine trade-offs—monorepo shape, event sourcing, auth provider lock-in, bounded contexts, or intentional ORM skips. Solo builders use it when a coding session surfaces a boundary or technology call that the next engineer would undo without explanation. Primary shelf is Build/docs because the artifact is committed documentation; it also supports Validate when scoping irreversible architecture. Agents should scan existing ADR numbers, draft concise rationale, and avoid boilerplate sections that do not add memory for the team of one.549installs3TddTDD is a Matt Pocock–style agent skill (Simplified Chinese) for solo and indie builders who want test-first development instead of bolting tests on after the fact. Install it when you are building features or fixing bugs and mention red-green-refactor, integration tests, or test-first workflow. The agent walks you through planning, then repeating small RED→GREEN cycles so each test responds to what you just learned in implementation—not a big upfront test suite that guesses behavior. It encodes a clear philosophy: tests document what the system does for users and callers, stay stable across refactors, and avoid mocking yourself into testing shapes instead of outcomes. Anti-patterns like horizontal slicing are called out explicitly with a WRONG vs RIGHT diagram. For agentic coding in Claude Code, Cursor, or Codex, it turns chatty “write some tests” into a disciplined loop aligned with real integration coverage.526installs4DiagnoseDiagnose is a Chinese-localized Matt Pocock-style agent skill that turns flaky or hard-to-explain failures into a repeatable investigation ritual instead of random code changes. Solo builders invoke it when something is broken, throwing, failing intermittently, or slower than before and they want the agent to enforce reproduction before fixes. The workflow walks through minimise the scenario, form hypotheses, add instrumentation, apply a targeted fix, and run regression tests—skipping a stage only when the reason is written down. A bundled hitl-loop template lets the human run scripted steps in the terminal while the agent consumes structured captures such as whether export errored and the pasted message. It applies while you are still building features, hardening before ship, or triaging issues in a running environment, as long as you can cooperate on repro steps. The skill does not replace automated test suites; it coordinates disciplined debugging when automated signal is thin or the bug is environmental.524installs5Setup Matt Pocock Skillssetup-matt-pocock-skills is a meta setup skill for repositories that adopt Matt Pocock’s engineering skill pack. Solo builders and small teams run it once (or again after tracker or docs layout changes) so agents stop guessing where issues live, which triage labels mean what, and how CONTEXT.md and ADRs should be read. The workflow is deliberately human-in-the-loop: explore the repo with git and filesystem reads, present findings section by section, explain each choice in plain language, and only then append an ## Agent skills block and docs/agents/ artifacts. It supports GitHub issues by default and local markdown trackers under conventions like .scratch/. Because downstream skills depend on this configuration, the skill is gated with disable-model-invocation and should precede issue conversion, triage, PRD drafting, diagnosis, TDD, architecture improvement, or zoom-out sessions when those skills lack tracker or label context.521installs6Improve Codebase ArchitectureImprove-codebase-architecture (Deepening) teaches how to safely deepen a set of shallow modules once you know their dependency graph. It assumes Matt Pocock–style vocabulary—module, interface, seam, adapter—and walks through four dependency categories so you pick the right testing strategy: merge and test directly for in-process logic, use local stand-ins like PGLite for substitutable infra, define ports at network seams you own, and inject mock adapters for true externals such as Stripe. Seam discipline keeps refactors honest: do not add ports without at least production and test adapters, and do not leak internal test seams onto public interfaces. For solo builders maintaining a growing SaaS or API, it turns ad-hoc file moves into a repeatable architecture pass your agent can apply before large features or extractions.520installs7CavemanCaveman is a journey-wide agent skill that toggles an ultra-compressed communication mode for coding assistants. After the user says caveman mode, talk like caveman, less tokens, or invokes /caveman, responses drop articles and hedging while preserving accurate technical content, unchanged code blocks, and precise error references. Persistence means the mode does not drift back to verbose prose across multi-turn debugging, planning, or review unless the user explicitly disables it. Solo builders adopt it when agent sessions feel chatty and expensive but they still need correct fixes and explanations on demand. The skill documents concrete before-and-after examples for React re-renders and connection pooling, plus exceptions when clarity outweighs brevity.513installs8Zoom OutZoom-out is a compact agent skill that tells the coding agent to step back from the current file and explain how the active section fits the wider system. Solo and indie builders install it for moments when a feature touches unfamiliar modules, legacy boundaries, or indirect callers and ad-hoc “what does this do?” chat stays too local. You invoke it when you need a higher-level perspective: which packages participate, who calls whom, and what the dependency sketch looks like before you edit or refactor. It is procedural knowledge packaged as SKILL.md—not an MCP server or static doc site—so it plugs into Claude Code, Cursor, Codex, and similar agents that honor skill triggers. Because comprehension repeats across implementation, review, and production debugging, treat it as multi-phase rather than tied to a single ship gate. Pair it with narrower debugging or code-review skills once you have the map and want line-level fixes or checklist-driven review.509installs9Handoffhandoff is a journey-wide agent skill from the mattpocock-skills-zh-cn bundle that compacts live context into a portable markdown handoff. Solo builders hit context limits, switch models, or open a clean session mid-feature; without a disciplined summary, the next agent re-derives decisions from scratch. This skill instructs the agent to capture what mattered in dialogue, point to authoritative files already on disk, and optionally recommend skills for the continuation. It deliberately avoids repeating content that lives in plans or PRs, which keeps handoffs short and trustworthy. Use it whenever you would otherwise paste twenty screenshots of chat history into a new window—across build implementation, ship review fixes, or operate firefighting—because the trigger is session continuity, not a single product phase.508installs10To Prdto-prd is a Matt Pocock–style workflow skill (Chinese instructions) that helps solo builders freeze intent after exploratory chats with a coding agent. Instead of re-asking discovery questions, the agent explores the repository if needed, respects domain glossary and ADRs, negotiates where features will be tested at architectural seams, and drafts a PRD aligned to a fixed template. User stories are intentionally exhaustive in As-a/I-want/so-that form, and implementation decisions capture modules, interfaces, contracts, and schema shifts without fragile file-path dumps. Prototype snippets may embed decision-dense shapes when prose would rot quickly. Issue tracker integration assumes project vocabulary from `/setup-matt-pocock-skills`. It fits builders who already debated a feature in chat and need a durable, agent-ready ticket before implementation planning. Outcome is a labeled issue your stack can pick up next—typically feeding deeper plan or task breakdown skills rather than jumping straight to code.506installs11To IssuesTo Issues is an agent skill for solo and indie builders who already have a plan, spec, or PRD and need a sane backlog in their issue tracker. It applies tracer-bullet vertical slicing: each ticket cuts through every integration layer so a finished slice is demoable or verifiable on its own, with a bias toward many thin slices instead of a few monoliths. The skill can pull an existing issue by reference, optionally explore the codebase so titles and descriptions match your domain glossary and ADRs, then present a numbered breakdown with type, blockers, and story coverage before asking you to tune granularity, dependencies, merges, and HITL versus AFK balance. After you approve, it creates issues using your tracker’s conventions. Use it when you want implementation tickets—not a new spec—from conversation context or linked planning artifacts, especially after planning skills have produced an approved direction.504installs12Write A SkillWrite-a-Skill is a meta agent skill for creating new agent skills with correct structure, progressive disclosure, and bundled resources. Solo builders use it whenever they outgrow one-off prompts and want reusable SKILL.md packages that Claude Code, Cursor, or Codex can discover via tight descriptions and clear triggers. The workflow starts by interrogating domain scope, use cases, and whether scripts are required, then drafts the folder layout (SKILL.md required; optional REFERENCE, EXAMPLES, and scripts), and finishes with a user review pass for coverage and clarity. Because skill authoring applies across idea exploration, build automation, ship checklists, and operate runbooks, it is tagged journey-wide with agent-tooling as the primary shelf. Following this skill reduces malformed frontmatter, vague descriptions that never get invoked, and monolithic SKILL files that blow context windows.504installs13PrototypeLogic Prototype is a Matt Pocock–style agent skill for solo builders who need to feel whether business logic, state transitions, or data models actually hold under edge cases before writing the real product. It walks you through stating the precise question, picking the project’s language, extracting logic into a small pure module (reducer, explicit state machine, pure transforms, or a bounded class API), and wrapping it in a minimal interactive terminal UI you drive by hand. The TUI is disposable; the logic module is shaped to lift into the codebase later. It fits when you are unsure if “X then Y” breaks a machine, whether a type can represent a corner case, or what an API should feel like—any scenario where reading specs is not enough. It deliberately excludes “what should this look like” UI work. Complexity is intermediate because you must choose the right abstraction and keep I/O out of the core.497installs14Triagetriage (Writing Agent Briefs) is a multi-phase productivity skill for solo and small-team builders who run GitHub-driven agent workflows. When an issue graduates to `ready-for-agent`, the brief posted as a structured comment becomes the durable spec; the original issue thread is context only. The guide trains you—and your agent—to write briefs that survive codebase churn: name behavioral contracts, types, and interfaces instead of paths and line numbers, and state testable acceptance criteria plus explicit boundaries. That pattern reduces failed AFK runs where agents chase renamed files or over-build neighboring features. It aligns with Prism’s Build PM shelf but equally supports Ship review prep and Operate iteration when you re-queue work. The content is localized (zh-CN) but the workflow is universal for Claude Code, Cursor, and similar agents executing against GitHub issues.489installs15Git Guardrails Claude CodeGit guardrails for Claude Code is a setup skill that wires a PreToolUse hook to intercept shell commands before they run. Solo and indie builders who let agents run git on their behalf use it to stop accidental or over-eager pushes, hard resets, aggressive cleans, and branch deletes that can destroy history or unpublished work. The workflow asks whether hooks belong in the current project or globally, copies the bundled blocker script into the Claude hooks directory, marks it executable, and registers it in settings so dangerous patterns never execute silently. It does not replace human review of merges or CI; it adds a hard gate at the agent boundary. For anyone shipping with Claude Code daily, it turns “the model ran git push” from a nightmare into a blocked attempt with an explicit denial message.483installs16Scaffold Exercisesscaffold-exercises is an agent skill for creators building structured coding courses—especially AI Hero–style repos—who need repeatable exercise trees that pass internal lint. It specifies how sections and exercises are numbered, which variant folders to create (problem with student TODOs, solution reference, or explainer-only conceptual material), and minimum files including non-empty readme.md stubs. The workflow ends with pnpm ai-hero-cli internal lint and iterative fixes before git commit, so solo educators do not ship broken links or empty readmes. Invoke when a plan lists new sections or exercises and you want the agent to mkdir, stub content, and validate against house rules instead of hand-rolling directories. Best for maintainers of pnpm monorepos using ai-hero-cli, not for one-off Markdown notes without that toolchain.478installs17Setup Pre CommitSetup Pre-Commit Hooks is an agent skill that automates adding Husky v9+ pre-commit automation to a JavaScript or TypeScript repo. It detects the package manager from lockfiles, installs husky, lint-staged, and prettier, initializes Husky, writes `.husky/pre-commit` to run lint-staged plus optional `typecheck` and `test` scripts, and adds lint-staged and Prettier defaults when configs are missing. Solo builders use it when they want commit-time formatting and fast feedback without manually copying hook recipes across projects. The skill omits typecheck or test lines when package.json lacks those scripts and tells you what was skipped. It targets local git workflow quality rather than remote CI, so it pairs well with existing test suites you already define in package.json.478installs18Migrate To ShoehornMigrate-to-shoehorn is a TypeScript testing skill (Matt Pocock / Total TypeScript lineage, documented in zh-CN packaging) that walks you through replacing `as` assertions in test files with @total-typescript/shoehorn utilities. Solo builders maintaining SaaS or API codebases often accumulate brittle tests that cast minimal stubs to full domain types, which trains everyone to ignore type errors and forces ugly `as unknown as` when probing invalid input. Shoehorn keeps the compiler honest while letting you pass only the fields a case actually exercises—especially valuable when a Request or entity type has dozens of properties but the example only cares about one nested id. The skill encodes before/after migration patterns for fromPartial and fromAny, plus npm install instructions. Use it during test refactors, when onboarding stricter eslint rules around assertions, or when a reviewer flags casts in new specs. It does not change runtime behavior; it improves how tests express intent and how agents refactor legacy suites safely.465installs19Design An InterfaceDesign an Interface is an agent skill that applies the ‘Design It Twice’ idea to modules and APIs. Solo builders reach for it when the first sketch feels obvious but probably wrong—designing a service boundary, plugin API, or internal module that other code will call for years. The workflow gathers requirements (problem, callers, operations, constraints, encapsulation), then spins parallel sub-agents with deliberately different constraints so outputs are not minor variations. You receive comparable signatures, realistic usage snippets, what each design hides, and honest trade-offs. That structured choice prevents premature coupling and makes later Build and Ship reviews faster because the public shape was debated upfront. It is especially valuable when agents otherwise jump straight to a single-file implementation without exploring simpler or more flexible alternatives.1installs20Edit Articleedit-article is a Chinese-language agent workflow (Matt Pocock–style) for solo builders and indie marketers who already have a rough article and need a disciplined edit pass—not a blank-page generator. The agent first segments the draft by headings, extracts the main point per section, and sequences sections so earlier ideas support later ones, treating the narrative like a small dependency graph. You confirm the proposed outline before any heavy rewriting, which keeps scope aligned with your intent. Each confirmed section is then rewritten for clarity, coherence, and reading flow, with paragraphs kept to at most 240 characters so mobile and skim readers stay engaged. Use it when a user asks to edit, revise, or improve an article draft in chat-driven writing sessions across Claude Code, Cursor, or similar agents. It fits blog posts, newsletters, docs-as-marketing, and landing-adjacent long copy once the first draft exists.1installs21Obsidian VaultObsidian Vault is an agent skill for solo builders who keep research and build notes in Obsidian and want the agent to respect vault layout instead of improvising folders. It targets a configured AI Research vault with flat structure, Title Case names, and index notes that list related [[wikilinks]]. Use it when you need to find an existing note, spin up a new learning unit, or wire dependencies at the bottom of a page. The workflow favors links over directories, which matches how many indies run a second brain alongside Claude Code or Cursor. Search covers filename walks, content grep, and backlink tracing; creation steps enforce naming, linking, and sequence numbering when applicable. It is a filesystem-oriented integration skill, not a sync plugin—your agent needs access to the vault path on disk.1installs22QaQA is an interactive agent skill for solo and indie builders who want to report bugs conversationally instead of writing perfect tickets by hand. You describe what you expected versus what happened; the agent lightly clarifies reproduction and stability, explores the codebase in the background to learn domain language and intended behavior, and decides whether one durable GitHub issue or several parallel issues fit the scope. Filed issues stay meaningful after refactors because they describe user-visible behavior, not internal file references. It fits Grow support workflows and also shows up when you are doing pre-launch QA in Ship or hammering a validate prototype. Triggers include mentions of a QA session, filing issues conversationally, or wanting help reporting bugs.1installs23Request Refactor Planrequest-refactor-plan is a workflow skill (Chinese instructions) for turning a vague refactor wish into an actionable, reviewable GitHub issue. The agent walks through discovery: the developer describes the pain and ideas, the agent reads the repository to confirm assumptions, surfaces alternative approaches, and runs a detailed implementation interview. Scope is locked so everyone knows what will and will not change. Test coverage around the affected area is checked; if it is thin, testing strategy is agreed before commits are listed. The centerpiece is a long, plain-language commit sequence where each step is tiny enough that the software should remain working throughout—aligned with Fowler’s incremental refactoring guidance. The issue captures durable decisions (modules, interfaces, architecture, schema, APIs) without brittle file paths or snippets that rot quickly. Testing decisions emphasize external behavior over implementation details. Solo and indie builders use it to avoid hero refactors that stall shipping; teams get a shared RFC artifact. Invoke when you want a refactor RFC, incremental steps, or a safe plan—not when you only need a one-line fix.1installs24ReviewReview is a Matt Pocock-style agent skill (Chinese SKILL.md) for solo builders who want review discipline without a single muddy chat thread. You name a fixed point—commit, branch, tag, or main—and the skill captures the three-dot diff and commits since that point, then evaluates changes on two independent axes. Standards asks whether the diff matches this repository’s documented coding standards; Spec asks whether the work matches the originating issue, PRD, or spec. Each axis runs in its own sub-agent, and this skill merges the findings for a clear comparison. Spec discovery follows a fixed order: issue references in commits (via your issue tracker doc), an explicit path, matching files under docs or specs, or a user prompt when nothing is found. It is built for “review since X,” in-progress branches, and pre-merge PR checks when you already track work in issues and written specs.1installs25TeachTeach is a journey-wide agent skill for solo builders and educators who want Claude or Cursor sessions to behave like a disciplined teaching workspace, not endless chat paraphrase. It standardizes how you maintain GLOSSARY.md: a single canonical language file where each term gets a crisp definition, preferred wording, and avoided aliases once the learner actually grasps the concept. The skill pushes language compression—defining hypertrophy or progressive overload in your domain’s words so later explainers and exercises stay consistent. Use it when onboarding yourself to a new stack, coaching a cofounder, or packaging a course-like agent workflow before you write docs or ship product copy that must match precise terms. It pairs naturally with explainer and exercise skills in the same repo family. It is meta-process guidance, not a quiz generator; you still supply the topic and evidence that the user understands each term before promotion into the glossary.1installs26Ubiquitous Languageubiquitous-language is a Matt Pocock–style agent skill (Chinese UI copy) that extracts domain-driven design vocabulary from the current conversation and persists it as UBIQUITOUS_LANGUAGE.md in the working directory. It runs a fixed ritual: scan messages for concepts, diagnose when one word means two things or two words mean the same thing, propose canonical terms, and emit sectioned markdown tables separating definitions from aliases to avoid. Solo builders use it when a spec sprawl of “order”, “invoice”, and “purchase” will otherwise infect APIs and UI copy. Because invocation is disabled for automatic model pickup, you trigger it when you want glossary work—not on every message. The skill fits validate-and-build handoffs: approved language flows into implementation plans, OpenAPI names, and support docs. It does not replace event storming workshops or full bounded-context mapping; it compresses terminology alignment into an agent-executable artifact your repo can diff in PRs.1installs27Writing BeatsWriting-beats is an agent skill for solo builders and creators who already have messy research or notes in markdown and want an article that reads as a journey, not a bullet-point argument. Invoke it when you have raw material and want narrative assembly with you in control of where the story goes next. The workflow mirrors choose-your-own-adventure: the agent proposes a few entry beats, you pick one, it appends only that beat to your article file, stops, re-reads from disk, and offers the next pivot options until the piece feels finished—often with unused fragments left in the quarry, by design. Beats scale from a single line to multi-paragraph vignettes but reject bloated “five-paragraph beats.” It fits Grow-phase content work for newsletters, founder stories, tutorials with tension, or SEO-adjacent long reads where engagement comes from momentum beat to beat. Works with Claude Code, Cursor, Codex, or any agent that can edit files and follow strict write-one-beat rules.1installs28Writing FragmentsWriting-fragments is an agent skill that runs a grilling-style interview to mine raw writing material before structure. Solo and indie builders install it when they have a topic or angle but do not want to lock into an outline yet—they want a novelist's diary of noticings they can shape later. The agent keeps questioning around the theme, and whenever either side produces usable text, it appends to one markdown document the user can edit live. Scope explicitly excludes outlines and phased plans; the standard is whether something is good writing stock, not whether it is a self-contained argument for a cold reader. If no path is given, the skill asks once where to save, then remembers it for the session. Outputs stay intentionally messy and heterogeneous so a future drafting or structuring step has rich fuel. It pairs naturally with planning or drafting skills after the fragment file feels full enough.1installs29Writing ShapeWriting-shape is a conversational agent workflow for solo builders and indie writers who already have raw material—a fragment list, unstructured prose, or a transcript in markdown—and need help turning it into something publishable without mangling the source file. You point the agent at the input pile; it reads the whole thing, proposes two or three opening candidates with different angles, and only after you commit to an opening does it grow the article beat by beat, debating whether each next chunk should be prose, a list, a table, a callout, a quote, or a code block. Approved blocks append to a dedicated article document as you go, so you see structure emerge in real time. It fits blog posts, changelog narratives, onboarding docs, and launch essays whenever you have substance but not sequence. Chinese SKILL.md; the ritual is language-agnostic for any agent that can edit markdown files.1installs