Development skills

Reviews code changes through documented engineering and product principles associated with named practitioners. Combines two engineering perspectives and one product perspective to produce findings with severity, attribution confidence, and technical reasoning for architecture, performance, or user experience issues.

• Reviewing architecture or public API changes
• Checking user experience alongside code correctness
• Strengthening a pull request before submission

Turn Git history into release notes and recommend the next version based on commit types and breaking changes. Check commit formatting, filter changes by package, and generate Markdown or JSON for automated release workflows.

• Prepare release notes before publishing a version
• Determine the next version from commit history
• Check commit message formats before merging

Manage parallel feature development with Git worktrees, separate working folders for different branches. Assign distinct ports, copy environment files, optionally install dependencies, and check for uncommitted changes and merged branches before removing outdated worktrees.

• Develop several feature branches at the same time
• Prepare a separate workspace for an urgent hotfix
• Give each AI agent its own branch and working folder

Review architecture and engineering growth plans through six questions covering capacity limits, technical debt, staffing, build-versus-buy costs, reliability, and security. Produce a structured verdict and three next steps before committing to major technical decisions.

• Reviewing a major architecture change
• Checking readiness for tenfold traffic growth
• Comparing in-house development with a vendor

Review engineering delivery plans, hiring proposals, and team changes through six operational questions. Assess delivery metrics, recruitment stages, management structure, and production practices, then produce a verdict and three concrete actions to address the findings.

• Reviewing quarterly delivery commitments
• Checking an engineering hiring plan
• Assessing a proposed team reorganization

Review code changes from three critical perspectives: production failures, maintainability, and security. Get a consolidated report that ranks findings by severity and provides merge guidance, helping examine assumptions that an ordinary self-review may overlook.

• Reviewing a pull request before merging
• Getting a second opinion on AI-written code
• Checking authentication or data access code

Plan a Claude Managed Agent around one clear job, then route work through setup, launch preparation, evaluation, and scheduling. Produce execution plans and curl commands that users run with their own Anthropic API key.

• Defining one clear job for a managed agent
• Preparing launch commands for an Anthropic account
• Planning evaluation and revision with an iteration limit

Write and review asynchronous C++ networking code using Boost.Asio or standalone Asio. The skill selects an implementation style for the installed library and C++ version, then checks memory lifetimes, concurrent writes, error handling, and build settings.

• Implementing asynchronous TCP or UDP servers and clients
• Reviewing buffer lifetimes and concurrent socket writes
• Adapting networking code to older Boost and C++ versions

Delegate research, coding, and testing from Claude Code to opencode workers. Run independent tasks in parallel with separate Git working directories, combine findings, track token use, and compare solo execution with coordinated workers.

• Delegate a small task to one opencode worker
• Implement independent changes in parallel
• Review a diff from four perspectives

Check that functions, methods, and imports exist in the software version being used before writing code. Identify uncertain calls, framework mix-ups, and deprecated interfaces so implementation decisions rely on verified details.

• Checking functions against an installed library version
• Avoiding API mix-ups between frameworks
• Verifying package import paths before coding

Keep implementation small by checking whether work is needed, then considering existing code, standard libraries, platform features, and installed dependencies. Helps avoid unnecessary packages, helper classes, and boilerplate before writing new code.

• Implementing a feature with minimal code
• Avoiding unnecessary package installations
• Reusing existing helpers and platform features

Monitor a pull request and handle CI failures, trusted review feedback, and merge conflicts in a dedicated worktree. The skill guides fixes, verification, controlled pushes, and replies under the user’s Git and GitHub CLI identity, with options for one-time or scheduled checks.

• Watching a pull request for new CI failures
• Applying trusted review feedback in an isolated worktree
• Resolving a pull request’s merge conflict

Review Qwen Code issues and pull requests through staged checks. Assess product fit, code simplicity, and CI evidence, then prepare English and Chinese comments that explain findings and flag decisions needing maintainer attention.

• Triage incoming Qwen Code issues
• Check pull requests against product direction
• Review changes for unnecessary complexity

Review local uncommitted changes, verify findings, and repeat focused repairs until the review converges or a blocker remains. Also supports Qwen Code issue fixes and review responses within workflows run through GitHub Actions.

• Review and repair local uncommitted changes
• Develop a focused fix for a selected issue
• Verify and address pull request feedback

Scan repository documentation, tests, and code for small, well-supported problems, then apply minimal fixes on one branch. Verify each fix before committing it separately, and record larger findings for reporting.

• Running scheduled repository maintenance
• Finding small issues in documentation, tests, and code
• Collecting separately verified fixes on one branch

Delegate code exploration, feature development, bug fixes, and reviews to Qwen Code through acpx, a command-line client for communicating with agents. Use ongoing sessions, separate task sessions, and structured output to coordinate development work.

• Asking questions about an unfamiliar codebase
• Creating projects and adding features
• Investigating bugs and failing tests

Apply the same operation across multiple files using parallel worker agents. The skill finds matching files, divides the work, and reports successes, failures, and skipped files, with a preview option before edits.

• Add license headers across source files
• Convert JavaScript files to TypeScript
• Fix the same lint issue in multiple files

Prepare pull request title and body files from the current branch diff and available test reports. Follow the repository template, include concrete reviewer checks, and provide an English body with a Chinese translation.

• Draft a pull request from current branch changes
• Prepare PR metadata files for CI or autofix
• Document reviewer checks and tested operating systems

Coordinate a small Qwen Code team using shared tasks and peer messages. Read-only teammates investigate separate questions, while an optional single writer implements changes in a separate Git worktree for review and verification.

• Split an investigation into clearly owned tasks
• Resolve conflicting findings through teammate messages
• Pass accepted research to a single implementation writer

Find unused components, files, translation keys, and other unnecessary code across a codebase. Document every consumer and removal impact in a tracking issue, then turn one maintainer-approved candidate into a focused pull request.

• Periodically checking for accumulated unused code
• Finding orphaned translation keys
• Recording removal candidates and their impact in an issue

Build a custom branded Qwen Code desktop package from its Tauri shell using a brand identifier and local logo. Apply app naming, icons, and startup screen changes, then report generated installers and their verification hashes.

• Create a desktop client with a company name and logo
• Build an installer for a supported operating system
• Configure a separate update feed for a branded app

Investigate growing memory usage in Qwen Code CLI by comparing heap snapshots, records of objects in memory. Trace what keeps objects alive, identify likely causes, and repeat the workload to verify a fix.

• Investigating steadily growing memory usage
• Tracing references that keep objects alive
• Finding growing arrays, caches, or event listeners

Guide substantial qwen-code feature development from investigation and design through implementation, testing, and review. Produce design documents and end-to-end test plans, compare behavior before and after changes, and address verified review findings.

• Developing features that span multiple files
• Documenting a design before implementation
• Comparing behavior before and after a change

Write Workflow scripts that divide research, reviews, or migrations among agents. The reference explains parallel and staged processing, independent verification, failure handling, budgets, and resuming runs so the script has a clear execution structure.

• Design a review workflow with independent verification
• Divide broad research among agents and combine findings
• Plan staged processing for a large migration