jnmetacode/superpowers-zh
20 skills17.4k installs146k starsGitHub
Install
npx skills add https://github.com/jnmetacode/superpowers-zhSkills in this repo
1Chinese Documentationchinese-documentation is a superpowers-zh skill (version 1.0.0, MIT) that applies 中文文案排版指北 conventions to Chinese technical documentation so prose reads professionally instead of machine-translated. Rules cover spaces between Chinese and English words, Chinese and digits, and digits with units, plus full-width and half-width punctuation consistency, preserved technical terms, and link formatting. The skill activates only on explicit /chinese-documentation invocation—agents must not auto-trigger from context per frontmatter. Reach for chinese-documentation when README files, API docs, or release notes target Chinese readers and typography errors would undermine credibility. Examples contrast correct Git and Jenkins spacing against cramped mixed scripts like 使用Git进行版本管理 versus properly spaced lines with Jenkins and CI terms. Hermes metadata tags the skill documentation and chinese. Developers localizing open-source or product docs benefit when agents otherwise omit CJK spacing discipline across commits and releases.1kinstalls2Using Superpowersusing-superpowers is the Chinese-localized bootstrap skill in jnmetacode/superpowers-zh that must run at conversation start to establish how agents find and apply other skills. It requires calling the Skill tool—not Read on skill files—whenever a skill might apply, including for clarifying questions, and defines a strict priority stack where user instructions in CLAUDE.md, GEMINI.md, or AGENTS.md override superpowers skills, which override default system prompts. Subagents assigned a specific task skip this skill per SUBAGENT-STOP guidance. Developers reach for using-superpowers when they want consistent, non-optional skill routing across Claude Code, Copilot CLI, and compatible agents rather than ad hoc file reads.987installs3BrainstormingBrainstorming is the Chinese edition of the Superpowers design-gate skill from jnmetacode/superpowers-zh. It blocks implementation—including code, scaffolding, or project setup—until the agent explores project context, asks clarifying questions one at a time, presents two to three options with trade-offs, and receives user approval on a written design. The workflow saves specs to docs/superpowers/specs/YYYY-MM-DD-topic-design.md, runs a self-check for ambiguity, and transitions to the writing-plans skill for implementation planning. A nine-step checklist covers context review, optional visual companions, option comparison, design presentation, spec commit, and user review. Brainstorming applies even to seemingly simple tasks like config changes or single-function utilities. Developers reach for it when agent workflows need disciplined Chinese-language design conversation before any coding starts.943installs4Receiving Code Reviewreceiving-code-review is a version 1.0.0 MIT-licensed agent skill from jnmetacode/superpowers-zh that replaces performative agreement with a six-step verification loop: read, restate, verify against the repo, assess technical fit, respond with evidence, and implement one item at a time. The skill explicitly bans phrases like "你说得太对了" or rushing to patch before validation and requires stopping when any review item is ambiguous. Developers reach for receiving-code-review when PR comments are unclear, technically questionable, or bundled as numbered lists that need item-by-item validation. It pairs with CLAUDE.md-style rules that forbid sycophantic review replies.923installs5Systematic Debuggingsystematic-debugging is a Superpowers-zh agent skill that blocks guess-and-patch debugging. Its iron rule requires completing root-cause investigation before proposing any fix, covering test failures, production bugs, performance issues, build failures, and integration problems. The workflow runs four sequential phases—root-cause investigation, hypothesis formation, targeted verification, and only then fix implementation—so agents do not mask symptoms with hasty patches. Developers reach for systematic-debugging under time pressure, after failed prior fixes, or when a bug looks trivial but keeps recurring. The skill is written in Chinese and mirrors the disciplined debugging methodology from the Superpowers skill family.919installs6Verification Before Completionverification-before-completion is a Claude Code skill (version 1.0.0, MIT) that blocks unsubstantiated success claims during development. Its iron rule: no fresh verification evidence means no completion claim. A five-step gate function requires identifying the proof command, running it fully, reading complete output and exit codes, verifying the conclusion, and only then stating results. A failure-mode table maps common claims—tests pass, linter clean, build succeeded, bug fixed, requirements met—to required evidence versus insufficient substitutes like prior runs or assumptions. Developers reach for verification-before-completion before commits, PRs, or handoffs when agents or teammates might skip rerunning tests.914installs7Chinese Code Reviewchinese-code-review version 1.0.0 from jnmetacode/superpowers-zh is a Chinese code review communication reference for domestic engineering teams. It balances directness with face-saving phrasing: use suggestions instead of commands, questions instead of blunt negation, but never skip bugs for politeness. Templates map harsh command-style feedback to constructive alternatives—for example replacing "you must change X" with "consider X because Y"—and provide tiered labels for must-fix, suggest-change, and reference-only comments. The skill activates only when users explicitly invoke `/chinese-code-review` and must not auto-trigger from context. Developers reach for chinese-code-review when reviewing PRs with Chinese-speaking teammates or open-source contributors who expect culturally tuned feedback that still flags defects clearly. The MIT-licensed skill is phrasing guidance, not an automated linter.881installs8Chinese Commit Conventionschinese-commit-conventions is an agent skill from jnmetacode/superpowers-zh (version 1.0.0, MIT license) that adapts Conventional Commits 1.0.0 for Chinese-speaking development teams. The skill documents Chinese type definitions for feat, fix, docs, and related commit types, plus commitlint, husky, commitizen Chinese templates, and conventional-changelog Chinese configuration for automated changelogs. Developers reach for chinese-commit-conventions only when explicitly invoking /chinese-commit-conventions to standardize bilingual Git history—not for automatic contextual triggering.874installs9Writing Planswriting-plans is a version 1.0.0 MIT skill from the superpowers-zh fork that turns specifications into comprehensive implementation plans before any code is written. The skill assumes the executing engineer has zero codebase context and documents every file to create or modify, code changes, tests, documentation references, and verification steps in small incremental tasks following DRY, YAGNI, and TDD principles. Plans save to docs/superpowers/plans/YYYY-MM-DD-feature-name.md and are designed to run inside a dedicated worktree created by the brainstorming skill. Developers reach for writing-plans when a multi-step feature spec needs a handoff-ready plan that an AI agent or junior engineer can follow without guessing file boundaries or test strategy.868installs10Test Driven Developmenttest-driven-development is a Chinese-language agent skill (version 1.0.0, MIT license) that enforces strict test-first development with AI coding agents. The iron rule states no production code without a failing test first—if code was written before tests, delete it and restart from red. The skill mandates the red-green-refactor cycle: write a failing test, verify the failure proves the right behavior, write minimal code to pass, then refactor. Developers reach for test-driven-development when agents skip tests, write implementation before specs, or rationalize one-off exceptions during features, bug fixes, refactors, or behavior changes. Exceptions require explicit human approval for one-off prototypes, generated code, or config files only.863installs11Subagent Driven Developmentsubagent-driven-development is version 1.0.0 of the jnmetacode/superpowers-zh Chinese localization of the Superpowers subagent workflow. When a written implementation plan contains mostly independent tasks and the developer stays in the current session, the skill dispatches one fresh subagent per task—each with precisely constructed instructions and no inherited session history—then runs two-stage review: specification compliance first, code quality second. Developers reach for subagent-driven-development instead of executing-plans or manual coding when parallelizable plan steps would otherwise bloat coordinator context or mix unrelated diffs. The skill includes a decision diagram comparing plans with independent tasks versus brainstorming-first flows, preserving coordinator context for orchestration while subagents own isolated execution.847installs12Executing Plansexecuting-plans is a Superpowers workflow skill, version 1.0.0, for developers executing a pre-written implementation plan in a separate session with review checkpoints. The agent announces use of the skill, reads the plan file, critically reviews dependency order, verification criteria, and hidden environment assumptions, then raises concerns before starting or proceeds with TodoWrite tracking. Each task runs with explicit verification such as npm test passing rather than vague confirm-it-works checks, followed by a commit per completed task. The skill notes that subagent-driven-development delivers higher quality on platforms like Claude Code or Codex when subagents are available. Developers reach for executing-plans when a plan already exists and needs disciplined, review-gated execution instead of ad-hoc coding.841installs13Chinese Git Workflowchinese-git-workflow is a jnmetacode/superpowers-zh skill version 1.0.0 under MIT license that provides complete Git workflow guidance adapted to Chinese platforms and team habits. It compares Gitee, Coding.net, 极狐 GitLab, and CNB across domestic access speed, free private repos, and CI systems including Gitee Go, Coding CI, GitLab CI, and .cnb.yml. The skill covers SSH and HTTPS credential differences, mirror sync configuration, and commit message conventions for mixed Chinese-English teams. Developers invoke it explicitly via /chinese-git-workflow rather than automatic context triggers. It addresses unstable GitHub access and CI/CD patterns that do not translate directly from foreign defaults.835installs14Requesting Code Reviewrequesting-code-review is a Superpowers skill (version 1.0.0, MIT) that dispatches a code-review sub-agent after tasks complete, major features land, or before merging to main. The reviewer receives organized evaluation context—description, plan or requirements, BASE_SHA, and HEAD_SHA—not the author's session history, so review stays focused on deliverables. Developers also use it when stuck, before refactors, or after complex bug fixes. The workflow uses git rev-parse for SHAs and the Task tool with a code-reviewer template. Core principle: review early and often, especially in subagent-driven development after each task.834installs15Using Git Worktreesusing-git-worktrees is a version 1.0.0 MIT-licensed skill from superpowers-zh that ensures feature work happens in an isolated workspace before implementation begins. The workflow detects existing isolation via GIT_DIR, GIT_COMMON_DIR, and current branch checks, prefers native platform worktree tools, and falls back to manual git worktree only when no native harness exists. A submodule guard prevents false positives when GIT_DIR differs from GIT_COMMON_DIR inside submodules. Developers reach for using-git-worktrees when starting a new feature or executing an implementation plan without risking uncommitted changes on main.833installs16Finishing A Development Branchfinishing-a-development-branch is a version 1.0.0 MIT-licensed agent skill (Chinese superpowers translation) that closes out feature work safely after tests pass. The skill follows a five-step flow—verify tests, detect environment, present options, execute the chosen path, and clean up—blocking merge or PR actions when the suite fails. Developers reach for finishing-a-development-branch when a feature branch is done and they need a structured decision between local merge, pull request creation, or branch deletion instead of ad-hoc git commands.827installs17Workflow Runnerworkflow-runner is a version 1.0.0 skill for developers who want to execute agency-orchestrator YAML workflows directly inside Claude Code, OpenClaw, or Cursor instead of wiring separate orchestration services. The skill reads a .yaml workflow file, extracts name, agents_dir, and inputs, then sequentially adopts each defined role from a directory such as agency-agents-zh while the current LLM acts as the runtime engine. Developers trigger workflow-runner when they supply a workflows/*.yaml file or ask for multi-role collaboration like product-manager plus architect PRD review. The documented flow has five ordered steps—parse workflow, load roles, gather inputs, execute steps, and summarize outputs—so agents do not skip orchestration stages.815installs18Dispatching Parallel Agentsdispatching-parallel-agents is a superpowers-zh skill (version 1.0.0, MIT) that teaches coding agents to delegate unrelated problems to dedicated sub-agents with isolated context. Instead of serially investigating every failing test file, subsystem, or bug in one session, the skill instructs the coordinator to craft precise per-agent briefs so workers do not inherit full chat history. Developers reach for dispatching-parallel-agents when CI surfaces failures across separate domains—auth tests, payment webhooks, and UI regressions—that share no state and can run in parallel. The workflow preserves coordinator context for synthesis while workers explore independently, cutting wall-clock debug time on multi-domain breakage.813installs19Mcp Buildermcp-builder is a version 1.0.0 MIT-licensed skill that systematizes building Model Context Protocol servers for AI assistants. The guide explains when to expose side-effecting operations as Tools, read-only URI-backed data as Resources, and reusable flows as Prompts, then prescribes a TypeScript layout with src/index.ts entry registration, feature-split tools/ and resources/ folders, shared lib/ clients, and a tests/ directory. Developers reach for mcp-builder when scaffolding a new MCP integration—not when wiring a single REST call—because it covers protocol primitives, structure conventions, validation, and deployment discipline end to end.813installs20Writing Skillswriting-skills is version 1.0.0 guidance that treats SKILL.md authoring as test-driven development. Developers write pressure scenarios with subagents, observe baseline failures without the skill, author documentation, confirm agents follow rules, then refactor to close loopholes. The skill requires superpowers:test-driven-development as background and references Anthropic skill best practices. writing-skills targets Claude Code skills in ~/.claude/skills and Codex skills in ~/.agents/skills/. Use it when creating, editing, or pre-deploy validating agent skills rather than writing application code.805installs