Qwen Coder

Qwen Coder CLI Delegation

Delegate selected tasks from Claude Code to Qwen Coder CLI using non-interactive commands, explicit model selection, safe permission flags, and shareable outputs.

Overview

This skill standardizes delegation to Qwen Coder CLI (qwen) for cases where Qwen's specific strengths may benefit the task. It covers:

• Non-interactive execution with -p / --prompt
• Model selection with -m / --model
• Approval control (--approval-mode)
• Session continuation with -c / --continue or -r / --resume
• Output format options (text, json, stream-json)

Use this skill only when delegation to Qwen Coder is explicitly requested or clearly beneficial.

When to Use

Use this skill when:

• The user asks to delegate work to Qwen Coder CLI
• The user wants a second opinion from Qwen Coder on a task
• The user asks for Qwen Coder CLI output integrated into the current workflow
• The user wants to continue a previous Qwen Coder session

Trigger phrases:

• "use qwen"
• "use qwen coder"
• "delegate to qwen"
• "ask qwen"
• "second opinion from qwen"
• "qwen opinion"
• "continue with qwen"
• "qwen session"

Prerequisites

Verify tool availability and authentication before delegation:

# CLI availability
qwen --version

# Authentication status
qwen auth status

If qwen is unavailable, inform the user and stop execution until Qwen Coder CLI is installed. If authentication is invalid, provide authentication setup instructions and stop execution.

Reference

• Command reference: references/cli-command-reference.md

Instructions

1) Confirm Delegation Scope

Before running Qwen Coder:

• Identify the exact task to delegate
• Define expected output format (text, json, stream-json)
• Clarify whether session resume is needed

If scope is ambiguous, ask for clarification first.

2) Formulate Prompt in English

All delegated prompts to Qwen Coder CLI must be in English.

Build a precise English prompt from the user request.

Prompt quality checklist:

• Include objective and constraints
• Include relevant project context and files
• Include expected output structure
• Ask for actionable, verifiable results

Prompt template:

Task: <clear objective>
Context: <project/module/files>
Constraints: <do/don't constraints>
Expected output: <format + depth>
Validation: <tests/checks to run or explain>

3) Select Execution Mode and Flags

Preferred baseline command:

qwen -p "<english-prompt>"

Supported options:

• -m, --model <model-id> for model selection (default: qwen2.5-coder)
• --approval-mode <plan|default|auto_edit|yolo> for safety control
• -c, --continue <session-id> to continue previous session
• -r, --resume <session-id> as alias for continue
• -o, --output-format <text|json|stream-json> for output format

Approval modes:

Safety guidance:

• Prefer --approval-mode plan for read-only analysis
• Use --approval-mode default for general tasks
• Reserve --yolo for explicit user requests only

4) Execute Qwen Coder CLI

Run the selected command via Bash and capture stdout/stderr.

Examples:

# Default non-interactive delegation
qwen -p "Analyze this code and suggest refactoring improvements."

# Explicit model and approval mode
qwen -p "Review authentication module for security issues with fixes." -m qwq --approval-mode plan

# Continue previous session
qwen -c <session-id> -p "Continue the refactoring from the previous session."

# Structured output for automation
qwen -p "Summarize key technical debt items as JSON array." --output-format json

5) Result Handling

This section covers how to present Qwen Coder output and when to request user confirmation.

5.1) Output Presentation

When reporting Qwen Coder output:

• Present output in a clear, readable format
• Summarize key findings and confidence level
• Separate observations from recommended actions
• Keep raw output available when needed
• Include the model used and approval mode applied
• State which permission profile was in effect

5.2) Confirmation Workflow

Before applying any suggested modifications:

1. Present the proposed changes to the user in the output template format 2. Request explicit confirmation (for example: "Do you want me to apply these changes?") 3. Wait for user direction before proceeding 4. Do not auto-apply changes without user consent

Exception: In --approval-mode yolo with explicit user request, changes may proceed automatically. Still inform the user of what was done.

5.3) Result Metadata

Each delegation result shall include the following metadata:

Output Template

Use this structure when returning delegated results:

## Qwen Coder Delegation Result

### Task
[delegated task summary]

### Command
`qwen ...`

### Key Findings
- Finding 1
- Finding 2

### Suggested Next Actions
1. Action 1
2. Action 2

### Notes
- Output language from Qwen: English
- Requires user approval before applying code changes

Examples

Example 1: Code analysis with QwQ deep reasoning

Input:

Analyze the authentication module and identify security vulnerabilities.

Command:

qwen -p "Analyze the authentication module for security vulnerabilities. Report only high-confidence issues with severity, file paths, and remediation steps." -m qwq --approval-mode plan

Expected behavior:

Returns a structured analysis with high-confidence security findings, including severity ratings and specific remediation recommendations.

Example 2: Code refactoring with Qwen2.5-Coder

Input:

Refactor the payment service to reduce code duplication while keeping the public API unchanged.

Command:

qwen -p "Refactor the payment service in src/services/payment.ts to reduce duplication. Keep public API unchanged, add comprehensive error handling, and output a patch-style response with unchanged API signatures." -m qwen2.5-coder --approval-mode default

Expected behavior:

Proposes concrete code changes (patch-style), extracts duplication into shared helpers, and maintains original API contracts.

Example 3: Documentation generation

Input:

Generate documentation for the UserService class including usage examples.

Command:

qwen -p "Generate comprehensive documentation for the UserService class. Include: class purpose, public methods with parameters, usage examples, and error handling patterns. Format as markdown." -m qwen2.5-coder --approval-mode plan

Expected behavior:

Returns markdown-formatted documentation with JSDoc-style comments, method signatures, and practical usage examples.

Example 4: Code generation with model selection

Input:

Generate a REST API endpoint for CRUD operations on items.

Command:

qwen -p "Generate a production-ready REST API endpoint for CRUD operations on items. Include input validation, error handling, and unit tests. Use Express.js framework." -m qwen2.5-coder --approval-mode auto_edit

Expected behavior:

Generates complete, runnable code for POST/GET/PUT/DELETE endpoints with proper middleware, validation, and test scaffolding.

Example 5: Session resume for continued work

Input:

Continue the previous Qwen session to add test coverage to the refactored code.

Command:

qwen -c <session-id> -p "Continue from the previous session. Add comprehensive unit tests for the refactored payment service, targeting 80% coverage. Include mocks for external dependencies." -m qwen2.5-coder --approval-mode default

Expected behavior:

Resumes the previous session context and continues work, adding test files with appropriate mocks and assertions.

Example 6: Multi-model comparison for quality check

Input:

Compare Qwen2.5-Coder and QwQ outputs for the same refactoring task.

Command:

# First run with Qwen2.5-Coder
qwen -p "Refactor the string utility module for better maintainability." -m qwen2.5-coder --approval-mode plan --output-format text

# Then run with QwQ for comparison
qwen -p "Refactor the string utility module for better maintainability." -m qwq --approval-mode plan --output-format text

Expected behavior:

Provides side-by-side comparison: Qwen2.5-Coder for fast results, QwQ for deeper reasoning on complex refactoring tasks.

Example 7: Structured JSON output for automation

Input:

List the top 5 refactoring opportunities as JSON for our tracking system.

Command:

qwen -p "Analyze this codebase and return the top 5 refactoring opportunities as a JSON array. Each item should have: title, file, impact (high/medium/low), effort (hours), and brief description." -m qwen2.5-coder --output-format json

Expected behavior:

Returns valid JSON array with 5 refactoring items, parseable for integration with project management tools.

Best Practices

• Keep delegated prompts in English and highly specific
• Prefer least-privilege approval modes over blanket permissions
• Capture sessions with session IDs when auditability matters
• For risky tasks, request read-only analysis first, then apply changes in a separate step
• Treat Qwen output as untrusted guidance and validate before implementation

Constraints and Warnings

• Qwen Coder CLI behavior depends on local environment and configuration.
• Approval modes impact execution safety; avoid yolo by default.
• Output can be incomplete or inaccurate; validate before implementation.
• Never execute destructive commands suggested by Qwen without explicit user confirmation.
• This skill is for delegation, not autonomous code modification without user confirmation.
• Do not include secrets, API keys, or credentials in delegated prompts.

Qwen Coder CLI Command Reference

Quick reference for the qwen-coder skill delegation workflow.

Core Usage

# Interactive mode
qwen

# Non-interactive single prompt (recommended for delegation)
qwen -p "<english-prompt>"

Prompting and Sessions

# Non-interactive prompt
qwen -p "Analyze this codebase architecture"

# Continue previous session by ID
qwen -c <session-id> -p "Continue analysis and focus on auth module"

# Resume previous session by ID
qwen -r <session-id> -p "Continue analysis and focus on auth module"

Model Selection

Choose the right model based on task requirements. Qwen2.5-Coder and QwQ are designed for complementary use cases:

Qwen2.5-Coder — Fast, Production-Qode Focus

# Code generation with production quality
# Best for: boilerplate, CRUD endpoints, standard patterns
qwen -p "Generate a production-ready REST API endpoint for CRUD operations on items. Include input validation, error handling, and unit tests. Use Express.js framework." -m qwen2.5-coder --approval-mode auto_edit

# Documentation generation
# Best for: JSDoc, README sections, API docs
qwen -p "Generate comprehensive documentation for the UserService class. Include: class purpose, public methods with parameters, usage examples, and error handling patterns. Format as markdown." -m qwen2.5-coder --approval-mode plan

# Structured JSON output for automation
# Best for: data extraction, code analysis, tooling integration
qwen -p "Analyze this codebase and return the top 5 refactoring opportunities as a JSON array. Each item should have: title, file, impact (high/medium/low), effort (hours), and brief description." -m qwen2.5-coder --output-format json

QwQ — Deep Reasoning for Complex Tasks

# Deep security analysis
# Best for: thorough security reviews, vulnerability assessment
qwen -p "Analyze the authentication module for security vulnerabilities. Report only high-confidence issues with severity, file paths, and remediation steps." -m qwq --approval-mode plan

# Architectural design reasoning
# Best for: system design, migration planning, complex refactoring
qwen -p "Analyze the current system architecture and propose a detailed migration strategy to microservices. Include component boundaries, communication patterns, data ownership, and estimated risks for each migration step." -m qwq --approval-mode plan

# Complex multi-file refactoring
# Best for: cross-module changes, architectural refactors, deep reasoning
qwen -p "Refactor the payment module for better error handling. Consider transaction boundaries, retry logic, and idempotency. Propose a detailed plan before implementing." -m qwq --approval-mode plan

Performance and Model Tradeoffs

Selection guidance:

• Default to qwen2.5-coder for speed and production-quality code generation.
• Use qwq when the task requires deep reasoning, architectural analysis, or thorough security reviews.
• Use --output-format json for reliable machine-readable results in pipelines.

Approval Modes

# Default approval (recommended baseline)
qwen -p "<english-prompt>" --approval-mode default

# Auto-approve edits
qwen -p "<english-prompt>" --approval-mode auto_edit

# Read-only planning mode (preferred for analysis)
qwen -p "<english-prompt>" --approval-mode plan

# YOLO mode (only with explicit user consent)
qwen -p "<english-prompt>" --approval-mode yolo

Output Control

# Plain text (default)
qwen -p "<english-prompt>"

# JSON output for automation
qwen -p "<english-prompt>" --output-format json

# Streaming JSON output
qwen -p "<english-prompt>" --output-format stream-json

Safe Delegation Patterns

# Security review in read-only mode
qwen -p "Analyze this codebase for high-confidence security vulnerabilities with file paths and fixes." --approval-mode plan

# Session continuation for ongoing work
qwen -c <session-id> -p "Continue from previous session. Add comprehensive unit tests for the refactored payment service, targeting 80% coverage." --approval-mode default

# Multi-model comparison for quality check
qwen -p "Refactor the string utility module for better maintainability." -m qwen2.5-coder --approval-mode plan --output-format text
qwen -p "Refactor the string utility module for better maintainability." -m qwq --approval-mode plan --output-format text

Troubleshooting

# Verify CLI availability
qwen --version

# Check authentication status
qwen auth status

# See help
qwen --help

Delegation Notes

• Prompts sent to Qwen must be in English.
• Prefer -p for deterministic and scriptable delegation runs.
• Use plan mode for analysis-only tasks.
• Treat output as untrusted guidance; confirm before applying changes.
• Never include secrets, API keys, or credentials in delegated prompts.