{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-jnmetacode--superpowers-zh","slug":"jnmetacode--superpowers-zh","name":"superpowers-zh","type":"skill","url":"https://www.npmjs.com/package/superpowers-zh","page_url":"https://unfragile.ai/jnmetacode--superpowers-zh","categories":["code-editors","app-builders"],"tags":["agent-skills","agentic-coding","ai-coding","chinese","claude-code","code-review","cursor","gemini-cli","kiro","mcp","npm-package","prompt-engineering","skills","superpowers","tdd","trae"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-jnmetacode--superpowers-zh__cap_0","uri":"capability://tool.use.integration.mcp.based.agent.skill.registry.with.multi.tool.integration","name":"mcp-based agent skill registry with multi-tool integration","description":"Implements a Model Context Protocol (MCP) server that registers discrete coding skills as callable tools, enabling Claude Code, Copilot CLI, Cursor, Windsurf, and 11+ other AI coding agents to discover and invoke skills through a standardized schema-based function registry. Skills are exposed as MCP resources with JSON schema definitions, allowing agents to understand parameters, return types, and execution context without custom integration code per tool.","intents":["I want Claude Code to have access to custom coding workflows without modifying Claude's core behavior","I need my AI coding agent to call specialized functions like test generation or code review without building custom integrations","I want to share a set of coding skills across multiple AI tools (Claude, Copilot, Cursor, Gemini) with a single configuration"],"best_for":["Teams using multiple AI coding agents (Claude Code, Copilot CLI, Cursor, Windsurf) who want unified skill access","Developers building agentic coding workflows that require standardized tool calling across heterogeneous LLM providers","Chinese-speaking development teams needing localized prompts and culturally-adapted coding practices"],"limitations":["MCP server must be running as a separate process — adds deployment complexity vs embedded integrations","Skill execution latency depends on MCP transport layer (stdio, HTTP) — typically 100-500ms overhead per skill invocation","Limited to skills that can be expressed as synchronous or async functions — stateful, long-running workflows require external orchestration","Chinese language prompts may not work optimally with non-Chinese-trained models (GPT-4, Gemini) without additional fine-tuning"],"requires":["Node.js 16+ (for MCP server runtime)","npm or yarn package manager","At least one compatible AI coding agent (Claude Code, Copilot CLI, Cursor 0.30+, Windsurf, Gemini CLI, or Hermes Agent)","MCP client support in the target AI tool (native support in Claude Code, Copilot CLI; plugin/extension required for others)"],"input_types":["code snippets (JavaScript, TypeScript, Python, Java, Go, Rust, etc.)","file paths and project structures","natural language prompts describing coding tasks","structured JSON parameters for skill configuration"],"output_types":["generated code (functions, classes, test suites)","code review feedback (structured JSON with line-level comments)","test results and coverage reports","refactoring suggestions with diff output","documentation and type definitions"],"categories":["tool-use-integration","agent-skills"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-jnmetacode--superpowers-zh__cap_1","uri":"capability://code.generation.editing.prompt.engineered.coding.skills.with.tdd.first.patterns","name":"prompt-engineered coding skills with tdd-first patterns","description":"Bundles 6 original Chinese-language coding skills (test generation, code review, refactoring, documentation, debugging, architecture design) as pre-crafted prompt templates that are optimized for agentic execution. Each skill encodes best practices (TDD-first approach, structured output formats, error handling patterns) as system prompts that guide LLM behavior without requiring fine-tuning, enabling consistent, high-quality code generation across different LLM backends.","intents":["I want my AI agent to generate tests BEFORE writing implementation code (TDD pattern)","I need consistent code review feedback that covers security, performance, and maintainability","I want the AI to suggest refactorings with clear rationale and before/after code examples","I need documentation generated that matches my team's style guide and includes examples"],"best_for":["Development teams practicing test-driven development who want AI agents to enforce TDD workflows","Chinese development teams needing prompts optimized for Chinese LLMs (Qwen, Baichuan) and Chinese coding conventions","Teams standardizing code review practices across distributed teams using AI agents","Projects requiring consistent documentation generation with cultural/linguistic localization"],"limitations":["Prompt quality depends on underlying LLM capability — weaker models (GPT-3.5, Gemini 1.5) may not follow TDD patterns consistently","Skills are static prompt templates — no dynamic adaptation based on codebase context or team preferences without manual prompt editing","Chinese-language skills optimized for Chinese LLMs; English-only models may produce lower-quality output due to prompt-model mismatch","No built-in feedback loop — skills don't learn from execution results or user corrections across invocations"],"requires":["LLM with function calling support (Claude 3+, GPT-4, Gemini 2.0, Qwen, Baichuan)","Minimum context window of 4K tokens (8K+ recommended for complex code review)","MCP client integration to invoke skills as tools"],"input_types":["source code (any language)","test specifications or requirements","code snippets for refactoring","existing documentation for style matching"],"output_types":["test code (Jest, Vitest, pytest, JUnit format)","code review comments (JSON with severity, line number, suggestion)","refactored code with explanation","markdown documentation with examples","debugging analysis with root cause and fix suggestions"],"categories":["code-generation-editing","prompt-engineering"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-jnmetacode--superpowers-zh__cap_10","uri":"capability://planning.reasoning.skill.versioning.and.a.b.testing.for.prompt.optimization","name":"skill versioning and a/b testing for prompt optimization","description":"Enables versioning of skill prompts and automatic A/B testing to compare different prompt versions. Routes a percentage of skill invocations to different prompt versions and collects metrics (execution time, output quality, user satisfaction) to determine which version performs better. Automatically promotes high-performing versions and deprecates low-performing ones. Supports gradual rollout (canary deployment) to minimize risk of bad prompt changes.","intents":["I want to test a new code review prompt on 10% of invocations before rolling out to 100%","I need to compare two test generation prompts to see which produces better tests","I want to automatically promote the better-performing prompt version after A/B testing","I need to track which prompt version is currently in use and revert if quality degrades"],"best_for":["Teams continuously improving skill prompts and wanting data-driven optimization","Organizations with strict quality gates that require A/B testing before deploying prompt changes","Teams managing multiple skill versions across different projects or teams","Data-driven teams wanting to measure prompt quality improvements quantitatively"],"limitations":["A/B testing requires sufficient traffic to reach statistical significance — low-traffic skills may need weeks to get reliable results","Metrics collection requires manual definition of quality metrics — no automatic way to measure 'good' code review or test","Versioning adds complexity to skill management — requires careful tracking of which version is in use where","Gradual rollout increases operational complexity — requires monitoring and manual promotion decisions","User satisfaction metrics require explicit feedback mechanism — not all users will provide feedback"],"requires":["Metrics collection infrastructure (logging, analytics platform)","A/B testing framework (built into superpowers-zh or external like LaunchDarkly)","Quality metrics definition (e.g., 'test pass rate', 'code review acceptance rate')","Sufficient traffic to reach statistical significance (typically 100+ invocations per version)"],"input_types":["skill name and parameters","optional: explicit version selection (e.g., 'use-version-2.1')","optional: user feedback on result quality"],"output_types":["skill result from selected prompt version","A/B test metadata (version used, metrics collected)","A/B test results (winning version, statistical significance, confidence interval)","version promotion/demotion recommendations"],"categories":["planning-reasoning","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-jnmetacode--superpowers-zh__cap_11","uri":"capability://code.generation.editing.custom.skill.creation.and.registration.framework","name":"custom skill creation and registration framework","description":"Provides a framework for developers to create custom skills by defining prompt templates, input/output schemas, and execution logic. Custom skills are registered in the MCP server and exposed to all connected AI agents with the same interface as built-in skills. Includes TypeScript/JavaScript SDK with type definitions, validation helpers, and testing utilities. Supports skill packaging and distribution via npm for community sharing.","intents":["I want to create a custom skill for my team's specific coding patterns or conventions","I need to wrap existing tools (linters, formatters, test runners) as AI skills","I want to create a skill that combines multiple built-in skills (e.g., 'generate-tests-and-run-them')","I want to share my custom skill with the community via npm"],"best_for":["Teams with custom coding practices that don't fit built-in skills","Developers wanting to integrate existing tools (linters, formatters, test runners) with AI agents","Organizations building domain-specific AI coding workflows (e.g., infrastructure-as-code, data pipeline generation)","Open-source contributors wanting to create and share custom skills"],"limitations":["Skill development requires JavaScript/TypeScript knowledge — not accessible to non-developers","Custom skills must follow MCP protocol — requires understanding of MCP concepts and APIs","Testing custom skills requires setting up MCP server and test harness — adds development overhead","Custom skills are only available to teams that install them — no automatic distribution like built-in skills","Skill quality varies — community-contributed skills may have bugs or poor prompts"],"requires":["Node.js 16+ and npm/yarn","TypeScript knowledge (or JavaScript with JSDoc type annotations)","Understanding of MCP protocol and superpowers-zh skill framework","Test framework (Jest, Vitest) for testing custom skills"],"input_types":["skill definition (prompt template, input/output schema, execution logic)","optional: existing tool or function to wrap as a skill"],"output_types":["custom skill package (npm module)","skill registration in MCP server","skill documentation and examples"],"categories":["code-generation-editing","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-jnmetacode--superpowers-zh__cap_2","uri":"capability://tool.use.integration.multi.provider.llm.skill.execution.with.fallback.routing","name":"multi-provider llm skill execution with fallback routing","description":"Routes skill invocations across multiple LLM providers (OpenAI, Anthropic, Google, local Ollama, Chinese providers like Qwen/Baichuan) with automatic fallback logic. Detects provider availability, handles rate limits, and retries failed requests using exponential backoff. Abstracts provider-specific API differences (function calling schemas, token counting, context window limits) behind a unified skill execution interface, enabling skills to run on any available LLM without code changes.","intents":["I want my coding agent to use Claude when available, fall back to GPT-4 if Claude is rate-limited, and use local Ollama as a last resort","I need to run the same skill on multiple LLM providers to compare output quality and cost","I want to use Chinese LLMs (Qwen, Baichuan) for Chinese code but fall back to Claude for English code","I need resilience — if one provider goes down, my agent continues working with another provider"],"best_for":["Teams using multiple LLM subscriptions (OpenAI, Anthropic, Google) who want cost optimization and redundancy","Organizations with hybrid cloud/on-premise setups wanting to use local LLMs (Ollama) with cloud fallback","Chinese development teams needing provider flexibility between international (Claude, GPT-4) and local (Qwen, Baichuan) models","Cost-conscious teams wanting to route expensive operations to cheaper providers while maintaining quality"],"limitations":["Fallback routing adds 50-200ms latency per skill invocation due to provider health checks and request routing logic","Output consistency varies across providers — same skill may produce different code quality/style depending on which LLM executes it","Rate limit handling is reactive (retry after hitting limit) not proactive — doesn't predict or prevent rate limit errors","Requires API keys for multiple providers — increases credential management complexity and security surface area","Token counting and context window limits differ per provider — skills optimized for one provider may fail on another with smaller context window"],"requires":["API keys for at least 2 LLM providers (e.g., OPENAI_API_KEY, ANTHROPIC_API_KEY)","Network connectivity to cloud LLM APIs or local Ollama instance running on localhost:11434","Configuration file specifying provider priority order and fallback rules","Node.js 16+ with async/await support for concurrent provider health checks"],"input_types":["skill name and parameters (JSON)","code context and file paths","provider preference hints (e.g., 'prefer-chinese-llm', 'prefer-local')"],"output_types":["skill result (code, review, documentation) from whichever provider succeeded","provider metadata (which provider executed, latency, token usage)","fallback chain log (attempted providers and failure reasons)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-jnmetacode--superpowers-zh__cap_3","uri":"capability://memory.knowledge.codebase.aware.context.injection.for.skill.execution","name":"codebase-aware context injection for skill execution","description":"Automatically extracts and injects relevant codebase context (imports, type definitions, related functions, test files, documentation) into skill prompts before LLM execution. Uses AST parsing and semantic analysis to identify code dependencies and include only relevant context (not entire codebase), staying within LLM context windows. Caches parsed codebase structure to avoid re-parsing on repeated skill invocations, reducing latency by 70-80%.","intents":["I want the AI to generate tests that import the correct modules and match my project's testing patterns","I need code review to understand my codebase's architecture and suggest refactorings that fit my patterns","I want documentation generated that references existing code examples and matches my codebase's style","I need the AI to suggest refactorings that don't break existing code that depends on the function being refactored"],"best_for":["Teams with large codebases (10K+ lines) where full-context prompting exceeds LLM context windows","Projects with strong architectural patterns or coding conventions that require context to maintain consistency","Teams doing incremental refactoring who need AI to understand existing code structure and dependencies","Polyglot projects (multiple languages) where language-specific context (imports, type systems) is critical"],"limitations":["AST parsing adds 200-500ms overhead per skill invocation for large codebases (100K+ lines) — caching helps but cold starts are slow","Context injection heuristics may miss relevant code in loosely-coupled architectures or dynamic code patterns (reflection, metaprogramming)","Codebase parsing only supports languages with mature AST parsers (JavaScript, TypeScript, Python, Java, Go, Rust) — limited support for niche languages","Cache invalidation requires file system watching — can miss changes if files are modified outside the agent's awareness","Context size limits still apply — even with smart selection, very large functions or complex dependency graphs may exceed context window"],"requires":["Local file system access to codebase (cannot work with remote-only code)","Language-specific AST parser (tree-sitter for JS/TS/Python, or language-native parser)","Minimum 4K token context window in LLM (8K+ recommended for large codebases)","File system watching capability (Node.js fs.watch or similar) for cache invalidation"],"input_types":["file path or code snippet to analyze","skill type (test-generation, code-review, refactoring) to determine context relevance","optional: explicit context hints (e.g., 'include-test-files', 'include-type-definitions')"],"output_types":["enriched skill prompt with injected codebase context","context metadata (files included, dependency graph, cache hit/miss)","skill result (code, review, documentation) informed by codebase context"],"categories":["memory-knowledge","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-jnmetacode--superpowers-zh__cap_4","uri":"capability://data.processing.analysis.structured.output.schema.enforcement.for.skill.results","name":"structured output schema enforcement for skill results","description":"Defines and enforces JSON schema constraints on skill outputs (code review comments, refactoring suggestions, test cases) to ensure machine-parseable, consistent results. Uses schema validation and retry logic — if LLM output violates schema, automatically re-prompts with schema examples and stricter instructions. Supports schema versioning to enable backward compatibility as skills evolve.","intents":["I want code review results as structured JSON with severity levels, line numbers, and actionable suggestions that I can programmatically process","I need test generation to output valid code that can be immediately executed without manual fixing","I want refactoring suggestions with before/after code diffs that I can apply automatically or review line-by-line","I need to parse and aggregate skill results across multiple invocations (e.g., code review from 5 different files)"],"best_for":["Teams building CI/CD pipelines that need to automatically process AI-generated code (tests, reviews, refactorings)","Organizations wanting to aggregate and analyze skill results across multiple projects or teams","Projects requiring strict output validation before code is committed or deployed","Teams integrating AI skills into existing tools (IDEs, code editors, GitHub Actions) that expect structured data"],"limitations":["Schema enforcement adds 1-3 retries per skill invocation if LLM output doesn't match schema — increases latency by 30-100% in worst case","Overly strict schemas may cause LLM to refuse valid but non-conforming outputs — requires careful schema design","Schema versioning adds complexity — old clients may not understand new schema versions, requiring migration logic","Some skills (creative code generation, architectural design) are harder to constrain with schemas — may require looser schemas that reduce validation value"],"requires":["JSON schema definitions for each skill (provided by superpowers-zh, customizable)","Schema validation library (e.g., ajv, zod) in Node.js runtime","LLM with strong instruction-following (Claude 3+, GPT-4, Gemini 2.0) — weaker models struggle with schema constraints"],"input_types":["skill parameters and code context","optional: custom schema overrides for specific use cases"],"output_types":["validated JSON output matching defined schema","validation error details if output doesn't conform","schema version metadata for backward compatibility"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-jnmetacode--superpowers-zh__cap_5","uri":"capability://planning.reasoning.skill.composition.and.chaining.for.multi.step.workflows","name":"skill composition and chaining for multi-step workflows","description":"Enables sequential execution of multiple skills with automatic data flow between steps (output of one skill becomes input to next). Provides a workflow DSL (YAML or JSON) to define skill chains, with conditional branching (if code review fails, run refactoring skill), error handling (retry failed steps, skip on error), and result aggregation (combine results from parallel skill invocations). Executes chains with dependency tracking to optimize parallelization where possible.","intents":["I want to run: generate tests → run tests → if tests fail, debug → refactor code → run tests again","I need to review code across multiple dimensions: security review → performance review → style review → aggregate all feedback","I want to generate documentation → validate documentation against code → regenerate if validation fails","I need to refactor code → generate tests for refactored code → run tests → commit if all pass"],"best_for":["Teams implementing complex AI-driven code workflows (TDD, continuous refactoring, multi-stage code review)","Organizations automating code quality gates that require multiple sequential checks","Projects needing AI-assisted code migration or large-scale refactoring with validation","Teams building agentic coding systems that require multi-step reasoning and execution"],"limitations":["Skill chaining adds latency proportional to chain length — 5-step chain may take 10-30 seconds vs 2-4 seconds for single skill","Error handling in chains is complex — failure in step 3 of 5 requires clear error propagation and recovery logic","Conditional branching requires explicit condition definitions — complex business logic (e.g., 'refactor if code review score < 7') needs careful specification","Parallel execution optimization is limited by skill dependencies — chains with many sequential dependencies cannot be parallelized","Debugging failed chains is difficult — requires detailed execution logs and step-by-step result inspection"],"requires":["Workflow DSL parser (YAML or JSON) — superpowers-zh provides built-in support","Async/await runtime for sequential and parallel execution (Node.js 16+)","Error handling and retry logic (exponential backoff, max retries configuration)","Logging and observability (execution traces, step results, timing information)"],"input_types":["workflow definition (YAML/JSON with skill names, parameters, branching logic)","initial input (code, file path, requirements)","optional: execution context (environment variables, secrets)"],"output_types":["final workflow result (aggregated output from all skills)","execution trace (all intermediate results, timing, errors)","workflow status (success, partial success, failure with error details)"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-jnmetacode--superpowers-zh__cap_6","uri":"capability://text.generation.language.chinese.language.skill.prompts.with.cultural.coding.conventions","name":"chinese language skill prompts with cultural coding conventions","description":"Provides 6 original coding skills with prompts optimized for Chinese language and Chinese development practices. Includes cultural conventions (naming patterns, code organization, documentation style) common in Chinese teams, and is optimized for Chinese LLMs (Qwen, Baichuan) which may have different training data and instruction-following patterns than English-trained models. Supports bilingual prompts (Chinese + English) for mixed-language teams.","intents":["I want my Chinese development team to use AI coding agents without language barriers or cultural mismatches","I need code review feedback that understands Chinese naming conventions and documentation standards","I want to use Chinese LLMs (Qwen, Baichuan) which are cheaper and faster for Chinese code, but need skills optimized for them","I need documentation generated in Chinese that matches my team's style and terminology"],"best_for":["Chinese development teams (mainland China, Taiwan, Hong Kong) using AI coding agents","Organizations using Chinese LLMs (Qwen, Baichuan, ChatGLM) for cost and latency optimization","Multinational teams with Chinese-speaking developers who prefer working in Chinese","Chinese open-source projects needing AI-assisted development with Chinese documentation"],"limitations":["Chinese prompts may not work well with English-only LLMs (GPT-3.5, older Gemini) — requires Claude 3+, GPT-4, or Chinese LLMs","Cultural conventions encoded in prompts may not apply to all Chinese teams — different companies have different standards","Bilingual prompts increase prompt length by 50-100%, reducing available context for code — may exceed context windows for large codebases","Chinese LLM availability and quality varies by region — some regions may have restricted access or lower-quality models","Translating skills between Chinese and English requires manual effort — automated translation loses nuance and context"],"requires":["LLM with Chinese language support (Claude 3+, GPT-4, Gemini 2.0, Qwen, Baichuan, ChatGLM)","Chinese language input/output support in terminal or IDE","Optional: Chinese LLM API key (Qwen, Baichuan) for cost optimization"],"input_types":["Chinese code or code with Chinese comments","Chinese requirements or specifications","Chinese naming conventions or style guide"],"output_types":["Chinese code (functions, classes, tests)","Chinese code review feedback","Chinese documentation and comments","Chinese refactoring suggestions"],"categories":["text-generation-language","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-jnmetacode--superpowers-zh__cap_7","uri":"capability://tool.use.integration.local.first.execution.with.ollama.integration.for.offline.coding","name":"local-first execution with ollama integration for offline coding","description":"Integrates with Ollama (local LLM runtime) to execute skills entirely on-device without cloud API calls. Supports popular open-source models (Llama 2, Mistral, CodeLlama) optimized for code generation. Automatically detects Ollama availability and falls back to cloud LLMs if local model is unavailable. Caches model weights locally to avoid re-downloading, reducing startup time from minutes to seconds on subsequent runs.","intents":["I want to use AI coding skills without sending code to cloud APIs for privacy/security reasons","I need to work offline or in air-gapped environments where cloud API access is restricted","I want to reduce latency by running models locally instead of making API calls to cloud providers","I need to avoid API costs by using free, open-source models running locally"],"best_for":["Organizations with strict data privacy requirements (healthcare, finance, government) that cannot send code to cloud APIs","Teams in regions with poor internet connectivity or high API latency","Cost-conscious teams wanting to avoid per-API-call charges by using free open-source models","Developers working offline or in air-gapped environments (airplanes, remote locations, secure networks)"],"limitations":["Local model quality is lower than cloud models (Claude 3, GPT-4) — expect 20-40% lower code quality for complex tasks","Requires significant local compute resources (8GB+ RAM, GPU recommended) — not suitable for low-end machines","Model download and setup takes 5-30 minutes depending on model size and internet speed — requires upfront time investment","Ollama support is limited to specific models (Llama 2, Mistral, CodeLlama) — cannot use proprietary models like Claude or GPT-4 locally","Local models have smaller context windows (2K-4K tokens) compared to cloud models (8K-100K tokens) — limits codebase context injection"],"requires":["Ollama installed and running (https://ollama.ai) — available for macOS, Linux, Windows","Local machine with 8GB+ RAM (16GB+ recommended for larger models)","GPU (NVIDIA, AMD, or Apple Silicon) strongly recommended for acceptable performance — CPU-only execution is very slow","Model weights downloaded locally (5-50GB depending on model size)","Network connectivity for initial model download (can be offline after download)"],"input_types":["code snippets or file paths","skill parameters","optional: explicit model selection (e.g., 'use-codellama-34b')"],"output_types":["generated code (functions, tests, documentation)","code review feedback","refactoring suggestions","execution metadata (model used, latency, token usage)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-jnmetacode--superpowers-zh__cap_8","uri":"capability://tool.use.integration.ide.and.editor.integration.via.mcp.client.plugins","name":"ide and editor integration via mcp client plugins","description":"Provides MCP client implementations for popular code editors (VS Code, Cursor, Windsurf, Vim, Neovim) that connect to the superpowers-zh MCP server and expose skills as editor commands and inline suggestions. Integrates with editor keybindings, context menus, and command palettes for seamless workflow. Supports editor-specific features (VS Code inline code actions, Cursor's native AI features, Vim's command mode) while maintaining consistent skill behavior across editors.","intents":["I want to generate tests for the current function without leaving my editor","I need code review feedback inline in my editor, with suggestions I can apply with a single click","I want to refactor code using AI without copying code to a separate tool","I need documentation generated for the selected code and inserted directly into my editor"],"best_for":["Developers using VS Code, Cursor, Windsurf, Vim, or Neovim as their primary editor","Teams wanting to integrate AI skills into existing editor workflows without context switching","Organizations standardizing on a single editor and wanting consistent AI skill access","Developers preferring keyboard-driven workflows (Vim, Neovim) who want AI skills accessible via commands"],"limitations":["Editor integration requires separate plugin/extension per editor — maintenance burden increases with each new editor","Editor-specific APIs differ significantly (VS Code extensions vs Vim plugins vs Neovim Lua) — code reuse is limited","MCP client must be running as separate process — adds complexity to editor setup and debugging","Editor performance may degrade if MCP server is slow or unresponsive — requires careful timeout and error handling","Some editors (Vim, Neovim) have limited UI capabilities — complex results (code review with multiple suggestions) are harder to display"],"requires":["Supported editor: VS Code 1.80+, Cursor 0.30+, Windsurf, Vim 9.0+, Neovim 0.9+","MCP server running locally (superpowers-zh MCP server)","Editor extension/plugin installed (provided by superpowers-zh or community)","Editor configuration file (.vscode/settings.json, .cursor/settings.json, etc.) with MCP server connection details"],"input_types":["selected code in editor","current file path and context","editor command (e.g., 'generate-tests', 'review-code', 'refactor')","optional: skill parameters via editor UI or command palette"],"output_types":["inline code suggestions (VS Code inline code actions)","generated code inserted at cursor position","code review feedback displayed in editor sidebar or inline comments","refactoring suggestions with before/after diffs"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-jnmetacode--superpowers-zh__cap_9","uri":"capability://automation.workflow.skill.execution.monitoring.and.observability.with.structured.logging","name":"skill execution monitoring and observability with structured logging","description":"Provides comprehensive logging and monitoring of skill execution including execution time, token usage, LLM provider, error details, and result quality metrics. Outputs structured logs (JSON format) that can be ingested into observability platforms (Datadog, New Relic, ELK Stack) for real-time monitoring and alerting. Includes built-in metrics (success rate, average latency, cost per skill) and dashboards for tracking skill usage and performance over time.","intents":["I want to monitor which skills are being used most frequently and optimize my workflow accordingly","I need to track API costs per skill and per team member to allocate costs accurately","I want to detect when a skill is failing frequently and investigate root causes","I need to measure skill quality (e.g., test pass rate, code review acceptance rate) to improve prompts"],"best_for":["Teams running AI skills in production who need observability and alerting","Organizations tracking API costs and wanting to optimize spend per skill","Teams measuring AI skill quality and iterating on prompts based on metrics","DevOps/SRE teams managing AI-assisted development infrastructure"],"limitations":["Structured logging adds 10-50ms overhead per skill invocation — may impact latency-sensitive workflows","Requires integration with observability platform (Datadog, New Relic, etc.) — adds operational complexity","Metrics are only as good as the data collected — requires careful instrumentation to capture meaningful metrics","Privacy concerns with logging code snippets and results — requires careful handling of sensitive code","Cost tracking requires accurate token counting per provider — token counting APIs may have delays or inaccuracies"],"requires":["Observability platform (Datadog, New Relic, ELK Stack, Prometheus) or local log aggregation","Structured logging library (winston, pino, bunyan) in Node.js","Configuration for log level, output format (JSON), and destination","Optional: custom metrics and dashboards in observability platform"],"input_types":["skill execution events (start, end, error)","execution context (skill name, parameters, LLM provider)","result metadata (tokens used, latency, quality metrics)"],"output_types":["structured JSON logs with execution details","aggregated metrics (success rate, latency percentiles, cost)","alerts for anomalies (high error rate, unusual latency, cost spikes)","dashboards showing skill usage trends and performance"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":38,"verified":false,"data_access_risk":"high","permissions":["Node.js 16+ (for MCP server runtime)","npm or yarn package manager","At least one compatible AI coding agent (Claude Code, Copilot CLI, Cursor 0.30+, Windsurf, Gemini CLI, or Hermes Agent)","MCP client support in the target AI tool (native support in Claude Code, Copilot CLI; plugin/extension required for others)","LLM with function calling support (Claude 3+, GPT-4, Gemini 2.0, Qwen, Baichuan)","Minimum context window of 4K tokens (8K+ recommended for complex code review)","MCP client integration to invoke skills as tools","Metrics collection infrastructure (logging, analytics platform)","A/B testing framework (built into superpowers-zh or external like LaunchDarkly)","Quality metrics definition (e.g., 'test pass rate', 'code review acceptance rate')"],"failure_modes":["MCP server must be running as a separate process — adds deployment complexity vs embedded integrations","Skill execution latency depends on MCP transport layer (stdio, HTTP) — typically 100-500ms overhead per skill invocation","Limited to skills that can be expressed as synchronous or async functions — stateful, long-running workflows require external orchestration","Chinese language prompts may not work optimally with non-Chinese-trained models (GPT-4, Gemini) without additional fine-tuning","Prompt quality depends on underlying LLM capability — weaker models (GPT-3.5, Gemini 1.5) may not follow TDD patterns consistently","Skills are static prompt templates — no dynamic adaptation based on codebase context or team preferences without manual prompt editing","Chinese-language skills optimized for Chinese LLMs; English-only models may produce lower-quality output due to prompt-model mismatch","No built-in feedback loop — skills don't learn from execution results or user corrections across invocations","A/B testing requires sufficient traffic to reach statistical significance — low-traffic skills may need weeks to get reliable results","Metrics collection requires manual definition of quality metrics — no automatic way to measure 'good' code review or test","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.26453450576900917,"quality":0.49,"ecosystem":0.7000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.15,"quality":0.25,"ecosystem":0.1,"match_graph":0.45,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:21.550Z","last_scraped_at":"2026-05-03T13:58:34.540Z","last_commit":"2026-04-28T15:32:18Z"},"community":{"stars":1886,"forks":207,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=jnmetacode--superpowers-zh","compare_url":"https://unfragile.ai/compare?artifact=jnmetacode--superpowers-zh"}},"signature":"LL9CulDFjB+qopmIZ5AalQkdt1wfFDlU6koG1LKOC1ICPrFFKhX0S1u3WQTjJRqfva2fiUTBHKpXdnLRuCRvDA==","signedAt":"2026-06-20T03:04:40.048Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/jnmetacode--superpowers-zh","artifact":"https://unfragile.ai/jnmetacode--superpowers-zh","verify":"https://unfragile.ai/api/v1/verify?slug=jnmetacode--superpowers-zh","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}