Zhao

Takes code, architecture notes, or a feature sketch and produces a README or API doc that explains the "why" and "how" without drowning readers in jargon.

Takes your changes and submits a PR that updates both English and Chinese README files in sync, keeping bilingual docs aligned without manual copy-paste.

Captures the full chat thread with timestamps and saves it as a timestamped log file you can search and retrieve later.

Takes an OpenAPI spec or raw API code and generates clear endpoint docs with example requests, response shapes, and error cases—ready to ship to users.

Defines when one skill should trigger another — lets you chain skills together so output from one feeds input to the next without manual handoff.

Walks through your repo structure and deployment target, then generates a working pipeline config (GitHub Actions, GitLab CI, etc.) tailored to your stack.

Analyzes logs, traces, or code to pinpoint bottlenecks—database queries, render loops, memory leaks—and proposes concrete rewrites with expected speedup.

Maps your product's critical paths, proposes test cases for each, and defines quality gates that prevent bad releases without slowing you down.

Reviews code or architecture for OWASP Top 10 and common vulnerabilities, flags high-risk patterns, and suggests a remediation for each issue found.

Reads your workflow config and automatically runs the right follow-up skills after a milestone — e.g., "after PRD done, run research, then spec, then handoff." No manual re-triggering.

Listens to what you're trying to do and recommends the skill that matches your goal, saving you from browsing the catalog yourself.

Reads a diff or PR and spots bugs, security gaps, and style drift. Flags the risky bits first, then suggests polish — with concrete rewrites you can steal.

Takes a feature request or product requirement and produces a complete API design: endpoints, schema, versioning strategy, and error handling—ready for engineering review.

Takes your problem statement and constraints, then lays out a feasible architecture with trade-offs named, dependencies mapped, and implementation order clear.

Takes your staged changes and generates a Conventional Commits–formatted message with type, scope, and description — readable by humans and bots.

Reads stack traces, logs, and code; narrows down the root cause by asking targeted questions; then walks you through the fix step-by-step.

Reads a Figma file and generates a PRD with component specs, spacing, typography, colors, and interaction notes—everything a frontend engineer needs to code it.

Reads your spec, flags scope creep, ambiguous requirements, and hidden dependencies. Asks clarifying questions—and only then proceeds to the build plan.

Writes test cases for your codebase, sets up a test suite, and identifies coverage gaps. Works with your existing framework or recommends one.

Guides you through PRD structure—goals, user stories, technical constraints, success metrics—in a persistent document you edit in place, not a chat.

Reads a function or module and rewrites it for clarity, removes duplication, and suggests naming changes—preserving logic while making the next person smile.

Logs each skill's success and failure, builds a semantic map of what worked, and auto-patches the codebase after each run — no manual eval needed.

Tracks progress on multi-step projects that pause, resume, or hand off to someone else. Remembers where you left off, surfaces blockers, and logs each transition.

Uses persistent markdown files for general planning, progress tracking, and knowledge storage (Manus-style workflow). Use for multi-step tasks, research projects, or general organization WITHOUT mentioning PRD. For PRD-specific work, use prd-planner skill instead.