xiaolai

Use when writing or reviewing NL artifacts and need to check for anti-patterns — vague quantifiers, prohibitions without alternatives, oversized skills, write-on-read-only agents, monolithic prompts, or linter-duplicating rules.

Use when scoring NL artifact quality, applying penalties, or calibrating lint judgment — contains the 100-point rubric with penalty tables per artifact type. Four worked calibration examples (Excellent Agent / Rewrite Agent / Excellent Rule / Weak Rule) live in `references/calibration-examples.md`, loaded on demand when anchoring borderline cases.

Universal NL programming conventions — SKILL.md open spec (agentskills.io), AGENTS.md as canonical universal memory file, vague-quantifier list, prompt engineering layers, naming conventions, the override system. Tool-specific schemas live in nlpm:conventions-claude / nlpm:conventions-codex / nlpm:conventions-antigravity.

Use when scoring or writing Antigravity (or legacy Gemini CLI) artifacts — covers .gemini/ paths, .agent/ workspace skills, gemini-extension.json, GEMINI.md, TOML slash commands, Gemini-lineage hook events. Spec is unsettled (Antigravity 2.0 launched 2026-05-19); many checks are advisory until PR-B verification.

Use when scoring or writing Codex CLI artifacts — covers .codex/config.toml schema, .codex-plugin/plugin.json, .agents/skills/ layout, Codex hook events, AGENTS.md hierarchy, marketplace.json, and the agents/openai.yaml sidecar.

Universal NL programming conventions — SKILL.md open spec (agentskills.io), AGENTS.md as canonical universal memory file, vague-quantifier list, prompt engineering layers, naming conventions, the override system. Tool-specific schemas live in nlpm:conventions-claude / nlpm:conventions-codex / nlpm:conventions-antigravity.

Multi-agent workflow patterns for Claude Code -- parallel dispatch, sequential pipelines, QC gates, retry loops, shared partials. Use when designing systems with multiple agents, commands, or processing stages.

Use when writing or reviewing NL artifacts and need to check for anti-patterns — vague quantifiers, prohibitions without alternatives, oversized skills, write-on-read-only agents, monolithic prompts, or linter-duplicating rules.

Audit a generated candidate EOU set for boundary quality, minimality, overlap, authority, operational value, and governance risk.

Audit value_invocations in run traces for EOUs with classification.judgment_authorized:true. Verifies invocations against the captured_workflow's declared priority (no F15), checks for drift over multiple runs (no F16), detects hallucinated value ids (no F17), catches silent decisions on contested cases (F14), and runs counterfactual-swap audit as the V1 anti-theater defense.

Audit EOU specs for Foundry V2 faceted classification, authority limits, schemas, validation, failure modes, trace, blast radius, and responsibility ownership.

Synthesize a Stage 0 captured_workflow (D2.4 step 1–5 outputs + per-app constitutional domain_values layer) from a user goal, structured 5-role reference set, and constraints. For users entering an unfamiliar craft domain who cannot articulate a workflow unaided, and for any user who needs the constitutional layer made explicit before downstream EOU generation begins.

Generate a minimal, ranked candidate EOU set from a messy workflow using Foundry V2 constraints. Candidates are proposal-only and cannot be activated.

Audit a generated candidate EOU set for boundary quality, minimality, overlap, authority, operational value, and governance risk before any candidate advances to specification. <example> Context: A generation run has just produced a candidate set; the owner wants to know which candidates survive audit before promotion. user: "$audit-candidate-eou-set foundry/self-evolution/candidate-sets/cs-generate-eou-candidates-20260520-1430.yml" assistant: "I'll run the eight tests (boundary, non-overlap, minimality, authority, operational value, counter-generation, set composition, high-stakes) and write the audit report under foundry/audits/candidate-set-audits/." </example> <example> Context: User wants to audit a candidate set that contains a generating EOU without a corresponding audit path. user: "$audit-candidate-eou-set ./my-candidates.yml" assistant: "I'll audit. Heads-up that if any candidate has authority_level approve/publish or proposes weakening validators, I'll escalate to FAIL regardless of other test outc

Audit value_invocations in run traces for EOUs with classification.judgment_authorized:true. Verifies invocations against the captured_workflow's declared priority (no F15), checks for drift over multiple runs (no F16), detects hallucinated value ids (no F17), catches silent decisions on contested cases (F14), and runs counterfactual-swap audit as the V1 anti-theater defense. <example> Context: An EOU with judgment_authorized:true has accumulated several run traces with value_invocations. The owner wants to verify the invocations are load-bearing, not citation theater. user: "$audit-judgment compose-dish" assistant: "I'll load compose-dish.yml, its app's captured_workflow, and the run traces under foundry/runs/compose-dish/. I'll check each value_invocation entry against F14-F17, then run counterfactual-swap audit on up to 5 sampled invocations. Verdict report goes to foundry/audits/judgment-audits/compose-dish.judgment-audit.yml." </example> <example> Context: An EOU with judgment_authorized:false is passed

Audit an EOU spec — classification, authority, validators, failure modes, trace, blast radius, responsibility. <example> Context: Auditing an EOU before promoting it to active. user: "$eou-audit eou-diagnose" assistant: "Loading spec + governance + maturity model; report goes to foundry/audits/eou-audits/." </example> <example> Context: Re-audit after applying an ECP. user: "$eou-audit foundry/eous/audit-foundry.yml" assistant: "Re-running. Rule 94 (executor != approver) is hard-checked first." </example>

Translate VMark documentation and app strings to all 9 supported locales with subagent-driven audit, proofreading, and cultural polish. Use when adding or updating website pages, React locale JSON (src/locales/en/*.json), or Rust locale YAML (src-tauri/locales/en.yml) that need multi-language support.

Test-driven CSS design system modifications. Run checks before/after CSS changes to verify token usage, variable definitions, fallbacks, and consistency. Use when modifying CSS tokens, fixing design inconsistencies, or auditing CSS architecture.

Build or update MCP server/client integrations for VMark. Use when configuring MCP servers, adding MCP tools, or updating MCP-related docs and settings.

Audit an implementation against a plan (dev-docs/plans/*). Use when a user asks to check for gaps, logic errors, or missing tests relative to a plan or Work Items.

Verify a completed implementation against a plan by running gates and checking acceptance criteria. Use when the user asks to verify work items or confirm completion.

Create comprehensive implementation plans and write them to plan files. Use when the user asks for a plan, comprehensive plan, systematic workflow design, or wants decisions documented in a plan file.

Implement or modify VMark React UI with project conventions (Zustand selectors, Tailwind v4, shadcn/ui). Use for components, hooks, stores, and UI behavior changes.

Implement or modify VMark's Rust/Tauri backend. Use when adding Tauri commands, menu items, filesystem integration, or platform behaviors in src-tauri.

Use when generating or auditing documentation in Docusaurus format — covers config, directory structure, frontmatter conventions, and build commands.

Use when generating or auditing documentation in MkDocs format — covers config, directory structure, frontmatter conventions, and build commands.

Use when generating or auditing documentation in plain Markdown format — covers config, directory structure, frontmatter conventions, and build commands.

Use when generating or auditing documentation in Sphinx format — covers config, directory structure, frontmatter conventions, and build commands.

Use when generating or auditing documentation in VitePress format — covers config, directory structure, frontmatter conventions, and build commands.

Use when writing, auditing, or generating documentation for projects in unsupported languages — covers docstring conventions, API doc extraction, and generic heuristic patterns.

Use when writing, auditing, or generating documentation for Go projects — covers docstring conventions, API doc extraction, and Go-specific patterns.

Use when writing, auditing, or generating documentation for Python projects — covers docstring conventions, API doc extraction, and Python-specific patterns.

Full audit→fix→verify cycle: Claude audits, Codex fixes, Claude verifies. Repeats up to 3 rounds until all issues are resolved or the user stops. Claude does all code reading and judgment; Codex does all file editing.

Diagnose the cc-suite setup in the current project. Runs the full health check, explains every issue, and fixes what can be fixed automatically. Skill counterpart to /cc-suite:diagnose.

Initialize cc-suite for the current project — sets up the AGENTS.md bridge, registers Codex and Claude MCP servers, and generates a .cc-suite.md config. Skill counterpart to /cc-suite:init.

Non-interactive re-run of all cc-suite bridge and registration scripts. No questions asked — idempotent escalation step after the diagnose skill finds issues it could not fix. Skill counterpart to /cc-suite:repair.

Use when writing, reviewing, or naming any cc-suite artifact — pick the canonical noun or verb from this registry rather than coining a synonym. Loaded by NLPM's scorer and checker when R51 is enabled in .claude/nlpm.local.md.

Use when creating, editing, or reviewing a cc-suite advisor agent (a value-over-rules persona under `.cc-suite/agents/`). Covers system-prompt phrasing, model choice, tool restrictions, working-dir scoping, budget/turn limits, and the file format. Use proactively whenever the user asks to "add an agent", "make an advisor", "write a reviewer", or edits anything under `.cc-suite/agents/`.

Send a bug or failing test to Claude Code for root-cause analysis and fix. Use when you've hit an error you can't trace, a test is failing for unclear reasons, or a behavior is wrong and the cause is deep in the codebase.

Delegate an implementation task to Claude Code. Use when you want Claude to write, edit, or refactor code directly in the project. Claude has full read/write access and will make the changes autonomously.

Router skill for Claude Cowork — the enterprise multi-cloud surface and Office agents. Cowork covers Claude for Work deployed on third- party clouds (Amazon Bedrock, Microsoft Foundry, LLM gateways), enterprise SSO, telemetry, the M365 connector, and policy controls. Office agents covers Claude in Excel and Slack-style office integrations. Use when the user asks about: deploying Claude for Work on Bedrock or Microsoft Foundry, integrating an LLM gateway, configuring enterprise SSO, enabling telemetry / audit logs, connecting M365, applying enterprise policies, Claude in Excel, or Slack-style office agent integrations. Skip: raw API on Bedrock / Vertex (use anthropic-platform-features), user-facing connectors directory (use claude-connectors), Claude Code CLI in enterprise contexts (use claude-code).

Router skill for Claude Connectors (the user-facing MCP integration surface on claude.com), Claude Desktop extensions (MCPB packaging), MCP Apps for Claude Desktop with their visual + interaction design guidelines, the directory of pre-built integrations (GitHub, Google Workspace, Microsoft 365, Slack, …), the user-facing Agent Skills surface, and the user-facing Plugins surface. Use when the user asks about: enabling a connector in the Claude app, building a custom connector, packaging a Desktop extension (MCPB), MCP Apps visual / interaction design rules, submitting to the connectors directory, OAuth + token handling for connectors, the GitHub / Google / Microsoft / Slack connector integrations, authoring user-installable Skills, or installing plugins via the Claude app. Skip: low-level MCP protocol spec (use mcp-spec), MCP servers run by Claude Code CLI (use claude-code), MCP connector exposed by the API (use anthropic-platform-features → SKILL-agents-and-tools).

Router skill for Claude Code (the CLI tool itself). Contains intent hints and a dispatch table that maps a user's question to the surface-specific deep-reference file Claude should Read next. Use when the user asks about Claude Code internals: editing .claude/settings.json or settings.local.json, authoring or debugging hooks (PreToolUse, PostToolUse, Stop, SubagentStop, Notification, UserPromptSubmit, PreCompact, SessionStart, SessionEnd, etc.), writing slash commands or agents, configuring MCP servers in .mcp.json, building plugins or marketplaces, setting ANTHROPIC_* / CLAUDE_* env vars, troubleshooting permission modes, understanding the ~/.claude/ directory layout, or asking "what does <feature> in Claude Code do". Skip: questions about the Anthropic Messages API (use anthropic-api), the Claude Agent SDK (use claude-agent-sdk), the MCP protocol spec (use mcp-spec), or general shell / git / programming topics not specific to Claude Code internals.

Router skill for the Claude Agent SDK — Anthropic's libraries for building autonomous AI agents that wrap the Claude Code CLI runtime. Ships in TypeScript (`@anthropic-ai/claude-agent-sdk` on npm) and Python (`claude-agent-sdk` on PyPI). Covers `query()` / `ClaudeSDKClient`, hooks (PreToolUse / PostToolUse / Stop / etc.), subagents, MCP servers (stdio / HTTP / SSE / SDK in-process), permission modes, the sandbox (Docker / Kubernetes), structured outputs (JSON Schema validation), session capture / resume / fork, and session storage adapters (`SessionStore`, `InMemorySessionStore`, S3/Redis/Postgres). Use when the user asks about: importing `@anthropic-ai/claude-agent-sdk` in TypeScript or `from claude_agent_sdk import ...` in Python, writing an agent that uses `query()` or `ClaudeSDKClient`, registering hooks via the SDK (`hooks: { PreToolUse: [...] }` / `hooks={"PreToolUse": [...]}`), defining MCP servers in SDK options, configuring `permissionMode` / `permission_mode`, building subagents with `AgentDefiniti

Router skill for Anthropic's news + research feeds — auto-refreshed daily from anthropic.com/news and anthropic.com/research. Use when the user asks about TIME-SENSITIVE Anthropic content: model launches ("did Claude X just release?"), product announcements, partnership news, region launches, new research papers, recent policy positions, or "what's new from Anthropic?" / "what did Anthropic just announce?" / "any recent research on X?" Skip: deep technical reference (use the other 7 skills — claude-code, anthropic-api, etc.); historical news older than ~30 items (link out to anthropic.com instead); detailed paper content (the digest carries title + summary + URL — Claude WebFetches the paper for depth on demand).

Router skill for Anthropic platform-side features that sit above the raw Messages API: Agent Skills format (the spec for `.skill` packages used by platform-managed agents), MCP connectors hosted by Anthropic, tool use (computer use, code execution, bash tool, define-your-own tools), build-with-claude features (extended thinking, message batches, citations, Amazon Bedrock, Google Vertex, embeddings, fast mode, context editing), manage-claude operations (workload identity federation, billing, identity), and the Managed Agents product. Use when the user asks about: writing an Agent Skill `.skill` package, Anthropic's hosted MCP connector, MCP Tunnels (connecting private-network MCP servers without opening inbound ports), the computer-use tool, the code_execution tool, bash tool, extended thinking, message batches, prompt caching strategy at the platform level, citations, deploying via Bedrock or Vertex, embeddings models, fast-mode behavior, context editing strategies, WIF setup, billing / cost reports, identit

Router skill for the Anthropic Messages API and adjacent surfaces (admin endpoints, compliance, beta features, models catalog) hosted under platform.claude.com/docs/en/api/. Use when the user asks about: POST /v1/messages, tool_use / tool_result blocks, count_tokens, message batches, streaming responses, prompt caching, prompt cache TTL / breakpoints, system prompts, anthropic-beta headers, the admin API (organizations / workspaces / API keys / invites), compliance endpoints (data residency, audit logs, retention), beta-only features behind a beta header, or the models catalog (model IDs, deprecation dates, context window sizes). Skip: questions about Claude Code (use claude-code skill), the Claude Agent SDK (use claude-agent-sdk), platform features beyond the raw API such as Agent Skills format or tool-use guides (use anthropic-platform-features), MCP connector docs (claude-connectors), or per-language auto-generated SDK reference (use anthropic-sdk's TypeScript / Python types directly via your IDE).

Router skill for the Model Context Protocol (MCP) open spec, covering the protocol itself (JSON-RPC framing, capabilities, lifecycle), the client and server roles, the transport layers (stdio / streamable HTTP / SSE), and the core primitives (tools, resources, prompts, sampling, roots, completion). Use when the user asks about: writing an MCP server (in any language), writing an MCP client, the JSON-RPC protocol framing, the initialize handshake, capability negotiation, the stdio transport, the streamable HTTP transport, the SSE transport, defining a tool / resource / prompt, sampling, roots, or completion. Includes the TypeScript SDK (`@modelcontextprotocol/sdk`) and Python SDK (`mcp`). Skip: Anthropic's hosted MCP connector (use anthropic-platform-features), the user-facing Claude Connectors directory (use claude-connectors), Claude Code's `.mcp.json` config (use claude-code → SKILL-mcp).

Use to deeply analyze core architecture — entry points, module boundaries, dependency graph, data flow, and structural patterns. Part of the grill deep-dive phase. Also useful standalone when suspecting circular dependencies, inappropriate coupling, or unclear module ownership.

Core conventions for all grill analysis skills — output formatting, severity ratings, evidence standards, and untrusted-input handling. Load whenever a grill analysis skill is active.

Use to hunt for edge cases, race conditions, boundary values, partial failures, and implicit assumptions across a codebase. Part of the grill deep-dive phase under Paranoid Mode. Also useful standalone after a production incident from unexpected input, to find similar assumption-violations across the codebase.

Use to analyze error handling, logging, observability, and configuration management across a codebase. Part of the grill deep-dive phase. Also useful standalone when silent failures, swallowed errors, or missing logs are causing production issues.

Use for initial codebase reconnaissance — quickly survey project structure, tech stack, config files, and existing documentation to establish context before deeper analysis. Always the first skill run during a grill review, and also useful standalone when orienting to an unfamiliar repository.

Use when the user asks to grill, roast, audit, interrogate, deep-review, or do a multi-angle architecture review of a codebase or directory. Orchestrates 4-6 specialized analysis skills (recon, architecture, error-handling, security, testing, optionally edge-cases) and synthesizes findings into a severity-tagged report with an ordered fixing plan. Saves the report as a markdown file in the target codebase.

Use to analyze the security surface of a codebase — authentication, authorization, input validation, secrets handling, and dependency vulnerabilities. Part of the grill deep-dive phase. Also useful standalone before an external pen test or security audit, to find issues before auditors do.

Use to analyze test coverage, test quality, CI/CD setup, and testing infrastructure. Part of the grill deep-dive phase. Also useful standalone when onboarding to a new project and needing to know which parts have coverage and which are completely untested.

Validate test strength with mutation testing and harden weak assertions. Covers Stryker (JS/TS), mutmut (Python), go-mutesting (Go), and cargo-mutants (Rust).

Initialize workspace TDD Guardian config and enable strict hooks for test/coverage enforcement.

Enforce coverage thresholds AND test quality — coverage without behavioral assertions is meaningless.

Produce findings-first code review with severity ordering, test-gap findings, and test-quality audit.

Build a comprehensive test matrix for changed behavior with explicit assertion strategy per case.

Global TDD governance policy. Enforces plan-first development, behavior-driven test quality, and strict completion gates.

Orchestrate strict TDD implementation across planner, implementer, test designer, coverage auditor, mutation auditor, and reviewer subagents.

Recurring error patterns from non-native English speakers in developer contexts: article misuse, preposition confusion, tense mismatch, 'I am agree'-style anti-patterns, and other frequent L2 slips. Use when scanning for patterns a reader can map back to familiar mistakes rather than rediscover from first principles.

Core English grammar rules most likely to trip non-native developers: articles, subject-verb agreement, tense consistency, prepositions, countable vs mass nouns, comparatives. Use when reviewing grammar correctness of prose written for developer contexts (commits, docs, emails).

Punctuation conventions for developer prose: commas (serial, Oxford, clause-joining), semicolons, colons, hyphens vs en-dashes vs em-dashes, apostrophes, quotation marks. Use when reviewing punctuation of documentation, commit messages, or any prose where mis-pointing changes meaning.

Technical writing patterns for developer prose: API documentation structure, README shape, error-message wording, terminology consistency, and the active vs passive voice trade-off. Use when the text under review is documentation, a README, an API reference, or an error string.

Per-context tone rubrics for developer communication: commit messages, PR descriptions, code comments, API docs, emails, inline chat. Use when judging whether the register and formality of a piece of text fit its destination, not just whether it is grammatical.

Meta-skill that routes to the five focused writing skills in this plugin. Loads nothing substantive on its own — read this to decide which of grammar-fundamentals, punctuation-rules, tone-calibration, technical-writing, or common-non-native-mistakes to consult.

This skill should be used when the user asks to "learn from past sessions", "extract lessons", "find what worked", "identify patterns in my workflow", "what mistakes did I make", "what decisions were made", or wants to synthesize wisdom and actionable insights from conversation history.

Use when auditing, extracting, pruning, or writing Claude Code memory files. Covers memory file format, MEMORY.md index conventions, staleness scoring, claim extraction heuristics, destination routing, mutation rules, and archive conventions.

This skill should be used when the user asks to "check git history", "trace code changes", "find when something was added", "correlate commits with sessions", "find hotspot files", or needs to mine git repository history for insights. Only applicable when the current project is a git repository.

This skill should be used when the user asks to "analyze conversation history", "parse JSONL files", "read past sessions", "search conversation logs", "find what happened in a session", or needs to work with Claude Code's .jsonl conversation format. It provides the canonical parsing infrastructure for echo-sleuth agents.

Use this skill when building applications with Gemini API hosted models, including Gemini and Gemma 4, working with multimodal content (text, images, audio, video), implementing function calling, using structured outputs, or needing current model specifications. Covers SDK usage (google-genai for Python, @google/genai for JavaScript/TypeScript, com.google.genai:google-genai for Java, google.golang.org/genai for Go), model selection, and API capabilities.

Use this skill when writing code that calls the Gemini API for text generation, multi-turn chat, multimodal understanding, image generation, streaming responses, background research tasks, function calling, structured output, or migrating from the old generateContent API. This skill covers the Interactions API, the recommended way to use Gemini models and agents in Python and TypeScript.

Use this skill when building real-time, bidirectional streaming applications with the Gemini Live API. Covers WebSocket-based audio/video/text streaming, voice activity detection (VAD), native audio features, function calling, session management, ephemeral tokens for client-side auth, and all Live API configuration options. SDKs covered - google-genai (Python), @google/genai (JavaScript/TypeScript).

Guides the usage of Gemini API on Google Cloud Vertex AI with the Gen AI SDK. Use when the user asks about using Gemini in an enterprise environment or explicitly mentions Vertex AI. Covers SDK usage (Python, JS/TS, Go, Java, C#), capabilities like Live API, tools, multimedia generation, caching, and batch prediction.

Use when generating workflow files, writing blueprints, or validating format — covers gh-aw markdown format, GitHub Actions YAML, blueprint YAML frontmatter, and template structure.

Use when designing event routing, preventing cascades, composing workflows, or choosing between label-based vs dispatch-based triggers for GitHub agent workflows.

Use when configuring permissions, handling fork PRs, sanitizing untrusted input, or setting up safe-outputs for agent workflows on GitHub.

Use when selecting, customizing, or composing built-in workflow templates — covers all 7 templates (triage, PR review, docs, release, stale, first-timer, incident) with customization points and composition patterns.