Qwen

Build a local interactive interface for exploring calculations, simple simulations, and weighted comparisons. Adjust inputs to see how results change, with visible formulas, units, and assumptions that explain what the numbers mean.

• Exploring how input values change a calculation
• Comparing options with adjustable scoring weights
• Estimating capacity with a simple worker model

Explore an existing Vitest 3.2 JSON test report to count results, search failed tests, and inspect file errors. Review original diagnostic details and keep tentative explanations separate from evidence, without launching tests.

• Check failure counts in an existing test report
• Search failures by file path or diagnostic text
• Inspect file errors separately from failed assertions

Create or update saved Dynamic Workflows, JavaScript scripts that organize repeatable agent tasks. Capture task order, dependencies, and final results in a reusable file, with a slash command for running the workflow.

• Saving a repeated task as a reusable workflow
• Updating the steps in an existing workflow
• Organizing parallel tasks and dependent steps

Compare a feature implemented in Qwen Code with Codex or Claude Code under the same scenario. Capture communication and terminal records, inspect tool definitions and outputs, and guide fixes toward matching observable behavior.

• Checking a reproduced feature against its reference agent
• Comparing tool definitions and required arguments
• Investigating differences in terminal output

Set up zvec-grep (zg) for use with Qwen Code. Check existing installation and settings, explain the integration changes, and request approval before installing the package and registering it with Qwen Code.

• Install zg and connect it to Qwen Code
• Check existing zg installation and integration settings
• Review configuration changes before installation

Reproduce a Codex or Claude Code feature in Qwen Code or another command-line agent. Capture requests, terminal output, and state changes, then use that evidence to implement focused behavior and add a verification path.

• Reproduce an existing agent's slash command
• Inspect request formats and tool definitions
• Compare terminal output and saved state

Prepare shared instructions for translating, rewriting, or extracting information from many independent files, then submit a plan through the DashScope Batch API. Processing runs asynchronously at half the realtime list price and delivers new files later.

• Translate many documents using shared terminology
• Rewrite independent files into a consistent format
• Extract structured data from a collection of files

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

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

Classify outstanding pull request CI failures, automated checks run on code changes, using logs and changed files. Produce JSON decisions recommending a rerun, a comment, or no action, and identify specific nondeterministic tests when evidence supports it.

• Sorting outstanding CI failures on pull requests
• Identifying transient failures suitable for reruns
• Checking whether PR changes caused a failure

Turn a vague request into a goal with one outcome, verifiable completion checks, boundaries, a stopping agreement, and instructions for blockers. It drafts the objective for review without starting the work described.

• Turning a vague intention into a verifiable goal
• Tightening the completion checks of an existing goal
• Defining boundaries and a stopping agreement

Review recent code changes for duplication, maintainability, and wasted work, then apply straightforward improvements. The workflow combines three parallel reviews, prioritizes small, low-risk fixes, and checks the edited code with relevant tests or project checks.

• Cleaning up code after implementation
• Polishing changes before opening a pull request
• Reducing duplication in recent changes

Compare repository documentation with current code, tests, and settings to find missing, incorrect, or outdated guidance. Update affected pages, prioritize problems that block readers, and check examples and navigation for consistency.

• Find outdated setup instructions
• Document existing features that lack guidance
• Check settings and command examples against code

Review local code changes with git diff and update the matching pages under docs/. Keep commands, settings, examples, and navigation aligned with current behavior so readers can understand the changes without reading the code.

• Documenting uncommitted feature changes
• Updating setup instructions after a refactor
• Replacing outdated commands and configuration examples

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

Create and customize Qwen Code extensions using templates for context, commands, skills, agents, and MCP servers that connect external tools. Validate configuration and referenced files, review executable behavior, and prepare the extension for local testing.

• Creating a Qwen Code extension from a template
• Packaging custom commands and skills in an extension
• Adding MCP servers or other extension integrations

Verify a qwen-code pull request in an isolated environment by comparing its behavior with a control build and running focused tests. Produce a report and machine-readable verdict that distinguish measured results from areas left untested.

• Verify the central behavior changed by a pull request
• Compare results between the PR and a control build
• Recheck earlier findings after a PR update

Create a functional application prototype from an initial idea. The workflow covers requirements, technology choices, plan approval, project setup, implementation, visual assets where needed, build verification, and instructions for starting the result.

• Building a website prototype from an idea
• Creating an initial mobile or desktop application
• Developing a playable 2D or 3D game prototype

Find alternative words and phrases that fit a sentence, audience, and tone. Suggestions distinguish close synonyms from related expressions, explain differences in meaning or formality, and include brief usage examples when helpful.

• Vary repeated words in a piece of writing
• Choose wording for formal or conversational contexts
• Compare subtle differences between similar words

Explore code structure and history using an index of code relationships and meaning-based search. Trace calls, assess change impact, find likely bug locations, generate architecture reports, and review pull requests for risk and conflicts.

• Tracing function calls and change impact
• Investigating code locations related to a GitHub issue
• Generating architecture reports and class diagrams

Test Qwen Code CLI behavior from model requests through tool execution. Reproduce bugs, check terminal interactions and MCP tool connections, and inspect API logs using real models or mock servers for controlled scenarios.

• Reproduce reported CLI bugs and verify fixes
• Test MCP tool connections through the CLI
• Check terminal rendering and keyboard interactions

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

Investigate difficult bugs through explicit hypotheses, targeted logs, and repeated checks against actual data. Keep an investigation journal to track findings, examine environment differences and leftover state, and confirm the root cause before applying a fix.

• Investigate a bug that survived an initial fix
• Trace tests that fail intermittently
• Compare local behavior with a user's report

Automate terminal interactions and capture screenshots before and after commands run. Define scenarios in TypeScript to review CLI appearance, document command flows, or record changing output such as progress bars, with optional animated GIFs.

• Review CLI appearance changes in a pull request
• Capture slash command interactions
• Create screenshots for usage documentation