jnMetaCode/superpowers-zh

Brainstorming turns ideas into design specifications through collaborative questioning before any implementation work. Use it before creating features, building components, adding functionality, or modifying behavior to explore user intent, requirements, and design.

Chinese Code Review provides communication templates and priority labels (must-fix/suggest/for-reference) for giving code review feedback in Chinese teams, avoiding over-politeness or bluntness. Use when explicitly invoked via /chinese-code-review to conduct or guide a code review.

Chinese Commit Conventions adapts Conventional Commits for Chinese teams with type tables, commit message templates, breaking change rules, issue linking, and changelog generation configs. Use it to set up commitlint, husky, and commitizen for Chinese-language commit workflows.

Chinese Documentation provides a style guide for Chinese technical documentation, covering spacing, punctuation, terminology, and bilingual API doc formats. Use it when a user explicitly invokes /chinese-documentation to improve the readability and consistency of Chinese technical writing.

Chinese Git Workflow documents configuration differences for Gitee, Coding.net, Jihu GitLab, and CNB, covering SSH/HTTPS credentials, remote mirror sync, and CI/CD integration. Use it when setting up or standardizing Git workflows for teams in China.

Dispatching Parallel Agents delegates independent debugging tasks to parallel subagents with isolated contexts, so each can work on a separate problem without interference. Use it when multiple unrelated test failures or subsystem issues can be investigated concurrently.

Executing Plans loads a written implementation plan, critically reviews it, executes all tasks with verification and commits, and reports completion. Use when you have a plan with review checkpoints and need to execute it in a separate session.

Finishing a Development Branch walks an agent through verifying tests, detecting the repository environment, presenting integration options (merge, PR, or keep), executing the chosen action, and cleaning up worktrees where appropriate. Use it when implementation is complete and a branch needs to be integrated.

MCP Builder provides a methodology for designing, implementing, testing, and deploying Model Context Protocol servers so AI assistants can connect external tools, resources, and prompts.

Receiving Code Review provides a disciplined process for evaluating code review feedback before acting, verifying suggestions against the codebase, asking clarifying questions when items are unclear, and pushing back with technical reasons when appropriate.

Requesting Code Review dispatches a code review subagent to find issues before they spread. Use it after completing tasks, implementing features, or before merging to validate work against requirements.

Subagent-Driven Development executes an implementation plan by dispatching a fresh subagent for each task, reviewing each task for spec compliance and code quality, and ending with a broad branch-wide review. Use it when executing a plan of largely independent tasks in the current session.

Systematic Debugging guides a rigorous four-phase process to find root causes before attempting fixes. Use it for test failures, production bugs, performance issues, or any unexpected behavior.

Test-Driven Development enforces a test-first workflow: write a failing test, see it fail, then write the minimum code to pass before refactoring. Use it for new features, bug fixes, refactors, and behavior changes; no production code without a failing test.

Using Git Worktrees creates an isolated Git worktree for feature development so changes don't affect the current branch. It detects existing isolation, prefers native worktree tools, and falls back to manual git worktree when needed.

Using Superpowers enforces checking and invoking relevant skills before any response or action, including clarifying questions. Use it at the start of any conversation when working with the Superpowers skill library.

Verification Before Completion enforces running verification commands and checking output before claiming tests pass, builds succeed, or bugs are fixed. It prevents false success claims by requiring evidence for every assertion.

Workflow Runner executes YAML-defined multi-agent workflows directly inside AI coding tools like Claude Code, using the current session's LLM as the execution engine. Use it when you have an agency-orchestrator YAML file or need multiple specialized roles to collaborate on a task without setting up API keys.

Writing Plans creates detailed implementation plans that break down multi-step coding tasks into small, testable steps with exact files, code, and tests, so another agent or developer can execute them without context.

Writing Skills guides creating and validating agent skills using test-driven development. Use when creating new skills, editing existing skills, or verifying a skill before deployment.