Agent skill

Agent Feature Reproduction

by QwenLM in QwenLM/qwen-code

Reproduces a feature from Codex or Claude Code in Qwen Code by running the reference agent under capture, reading the traces, then implementing matching behavior.

Apache-2.0Auto-check passedDevelopment

Install Agent Feature Reproduction

skills CLI
$ npx skills add QwenLM/qwen-code --skill agent-reproduce-feature -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install QwenLM/qwen-code agent-reproduce-feature --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/QwenLM/qwen-code.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.qwen/skills/agent-reproduce-feature .claude/skills/agent-reproduce-feature && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
agent-reproduce-feature
GitHub stars
28k
Token cost
~1.5k tokens
SKILL.md length
595 words
Files
6 (incl. scripts, references)
Skills in repo
41
Repo updated
First seen
Licence
Apache-2.0

At a glance

Reproduces a feature from Codex or Claude Code in Qwen Code by running the reference agent under capture, reading the traces, then implementing matching behavior.

  • Works in 8 steps: Define the feature surface in one… → Select codex or claude-code as the… → Inspect the target repo enough to… → …
  • Cloning a slash command or UI behavior from Codex into Qwen Code
  • SKILL.md covers Purpose, Reference Agent Selection, Workflow and Capture Defaults, plus 2 more sections
  • Runs Python and Shell scripts from its folder; calls claude and codex

What it does

Your current session serves as the test harness here, and a nested reference agent, either Codex or Claude Code, runs as the program under test. The skill asks once which reference to use if you have not said, discovers the local launch command rather than assuming it, and defines the feature in one sentence together with a minimal prompt that triggers it.

Capture comes from several scripts: capture_state.py records local agent state before and after the scenario, run_with_mitm.sh captures HTTP request bodies, run_tmux_capture.sh records interactive terminal output, and an llm_dump.py helper is included as well. From the traces the agent extracts prompt changes, request shape including messages, tools and schemas, visible terminal states, file edits and error paths.

It then implements the smallest compatible behavior in the target repo, which defaults to the current directory, following the repo's existing patterns, adds focused tests or a smoke command, and hands off to an alignment skill when parity needs more iteration. A reference note on the capture workflow should be read before the first capture.

When your agent uses it

  • Cloning a slash command or UI behavior from Codex into Qwen Code
  • Capturing the request bodies and tool schemas another agent sends
  • Recording a terminal-visible feature of Claude Code to match it elsewhere

Example prompts

  • “Reproduce Claude Code's plan mode in this repo, using Claude Code as the reference agent.”
  • “Capture what Codex sends to the model when I run its review command, then build the same in Qwen Code.”
  • “Use codex as the reference and record the terminal output for the status feature.”

Requirements

  • Codex or Claude Code installed locally as the reference agent
  • tmux, for terminal capture
  • Python and a MITM capture setup for the bundled scripts

Workflow steps

8 steps, taken from the first numbered list in SKILL.md.

  1. Define the feature surface in one sentence: command, trigger, expected UI/output, and a minimal prompt that exercises it.
  2. Select codex or claude-code as the reference agent and discover its local launch command.
  3. Inspect the target repo enough to identify the likely module boundaries and Qwen Code launch command before changing code.
  4. Run the nested reference agent against the feature with capture enabled
  5. Extract behavioral facts from the trace
  6. Implement the smallest compatible behavior in Qwen Code using its existing patterns.
  7. Add focused tests or a reproducible smoke command.
  8. Hand off to $agent-reproduce-align when implementation exists and parity needs iteration.

What it can do on your machine

Read from SKILL.md and the folder at commit d9c6f8c. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 4 files in scripts/ (Python and Shell), which the agent can run.

    Shell commands in SKILL.md call:

    • claude
    • codex

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Agent Feature Reproduction loads about 1.5k tokens when it runs, and up to ~2.7k if it reads all its reference files. Until then it costs about 74 tokens; SKILL.md has 595 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~74
When it runs · the whole SKILL.md, loaded when a task matches
~1.5k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~2.7k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from QwenLM/qwen-code at commit d9c6f8c, republished under its Apache-2.0 licence (© QwenLM). 595 words, ~1,457 tokens.

Download SKILL.mdSave it as .claude/skills/agent-reproduce-feature/SKILL.md (or your agent's skills folder). This skill also uses 5 other files; get the full folder from GitHub.
name
agent-reproduce-feature
description
Use when reproducing an existing Codex or Claude Code feature in Qwen Code or another agent CLI by choosing a reference agent, capturing HTTP request bodies, prompts, tool/function schemas, terminal output, and then implementing the matching behavior in the target repo.

Agent Reproduce Feature

Purpose

Use this skill to turn an observed feature from a reference agent into an implementation task for Qwen Code. The workflow treats the current session as the outer harness and runs a nested reference agent process as the program under test.

Default target repo: the current working directory. Use a user-specified path only when the user explicitly provides one.

Reference Agent Selection

Start by selecting exactly one reference agent:

  • codex: use nested Codex as the reference implementation.
  • claude-code: use nested Claude Code as the reference implementation.

If the user did not choose one, ask once before capture. Then discover the local commands instead of assuming them:

sh
command -v codex || true
command -v claude || command -v claude-code || true

Record the selected adapter in the run notes or scenario:

json
{
  "reference_agent": "codex",
  "reference_interactive_command": "codex",
  "reference_headless_command": "codex exec",
  "target_agent": "qwen-code",
  "target_repo": "."
}

Workflow

  1. Define the feature surface in one sentence: command, trigger, expected UI/output, and a minimal prompt that exercises it.
  2. Select codex or claude-code as the reference agent and discover its local launch command.
  3. Inspect the target repo enough to identify the likely module boundaries and Qwen Code launch command before changing code.
  4. Run the nested reference agent against the feature with capture enabled:
    • Local state capture via scripts/capture_state.py before and after the scenario.
    • HTTP/body capture via scripts/run_with_mitm.sh.
    • Terminal capture via scripts/run_tmux_capture.sh when the feature is interactive or TUI-visible.
    • Headless/non-interactive execution when the feature has a stable command-line path.
  5. Extract behavioral facts from the trace:
    • system/developer prompt deltas relevant to the feature
    • request body shape, including messages, tools, functions, schemas, tool choice, model settings
    • visible terminal states and command output
    • local agent state changes, file edits, exit status, and error paths
  6. Implement the smallest compatible behavior in Qwen Code using its existing patterns.
  7. Add focused tests or a reproducible smoke command.
  8. Hand off to $agent-reproduce-align when implementation exists and parity needs iteration.

Read references/capture-workflow.md before running capture for the first time in a session.

Show full SKILL.md (284 more words)Show less

Capture Defaults

Prefer a fresh output directory per run:

sh
mkdir -p .repro-runs/slash-command-baseline
.qwen/skills/agent-reproduce-feature/scripts/run_with_mitm.sh \
  .repro-runs/slash-command-baseline \
  -- codex exec "exercise the Codex feature here"

For Claude Code, use the discovered headless command if available; otherwise use tmux:

sh
.qwen/skills/agent-reproduce-feature/scripts/run_tmux_capture.sh \
  .repro-runs/slash-command-claude \
  claude

For interactive slash commands or terminal rendering, use tmux:

sh
.qwen/skills/agent-reproduce-feature/scripts/run_tmux_capture.sh \
  .repro-runs/slash-command-tui \
  codex

The mitm script sets common proxy and CA variables for Node, Python, and curl-based CLIs. If TLS fails, read the certificate notes in references/capture-workflow.md and fix trust before interpreting missing traffic as product behavior.

Capture reference-agent state before and after a run:

sh
.qwen/skills/agent-reproduce-feature/scripts/capture_state.py \
  snapshot .repro-runs/slash-command-baseline/state-before \
  --agent codex

# Run the reference scenario here.

.qwen/skills/agent-reproduce-feature/scripts/capture_state.py \
  snapshot .repro-runs/slash-command-baseline/state-after \
  --agent codex

.qwen/skills/agent-reproduce-feature/scripts/capture_state.py \
  diff \
  .repro-runs/slash-command-baseline/state-before \
  .repro-runs/slash-command-baseline/state-after \
  --out-dir .repro-runs/slash-command-baseline/state-diff

Use --agent claude-code to snapshot ~/.claude instead of ~/.codex. Use --root PATH only for a custom state directory or tests.

Implementation Rules

  • Do not copy all captured prompt text into Qwen Code. Convert it into the minimum behavior, schema, or test needed.
  • Treat captured request bodies as sensitive local artifacts. Redact tokens before saving examples into docs, commits, issues, or PRs.
  • Treat state diffs as sensitive local artifacts too. The state tool redacts common token shapes and omits content for sensitive paths, but review state-diff.md before copying any excerpt into a tracked file.
  • Keep the first implementation narrow: one feature, one trigger path, one observable parity target.
  • Prefer compatibility tests that assert behavior over brittle tests that assert exact prompt wording.
  • If a captured schema reveals a stable public contract, encode that contract as a typed structure or fixture in Qwen Code.

Done Criteria

  • A baseline reference-agent trace exists under .repro-runs/ or an equivalent ignored/local path.
  • Reference-agent state changes are captured or explicitly marked as not relevant for the scenario.
  • Qwen Code contains a focused implementation and at least one verification path.
  • Any user-visible command behavior is documented in Qwen Code if that repo already documents similar features.
  • The next parity step can be run by $agent-reproduce-align without re-discovering the setup.

© QwenLM, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 5 other files (scripts, references) in .qwen/skills/agent-reproduce-feature of QwenLM/qwen-code.

  • SKILL.md
  • references/capture-workflow.md
  • scripts/capture_state.py
  • scripts/llm_dump.py
  • scripts/run_tmux_capture.sh
  • scripts/run_with_mitm.sh

Open the folder on GitHubat commit d9c6f8c

Compare with similar skills

Agent Feature Reproduction next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Agent Feature Reproduction compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Agent Feature Reproduction this skillQwenLM/qwen-code28k—~1.5kAutomated safety check: PassApache-2.0
Deep Reviewdyad-sh/dyad22k—~1.4kAutomated safety check: PassCustom licence
Mori Agent Bridgevaayne/mori303—~1.7kAutomated safety check: PassMIT
CommitHappenmass/omux102—~224Automated safety check: PassNone
Project Session ManagerYeachan-Heo/oh-my-claudecode40k—~4kAutomated safety check: PassMIT
Openspec Workflow RouterHsienW/chat-gun143—~923Automated safety check: PassCustom licence

Similar skills

  • Deep Review

    dyad-sh/dyad

    Deep multi-agent code review run locally — a fleet of parallel finder agents reviews the diff from independent angles, then adversarial verifier agents reproduce each finding before it is reported.

    22k GitHub stars~1.4k tokensUpdated yesterday
    DevelopmentAuto-check passed
  • Use Mori CLI to enable agent-to-agent communication and coordination across Mori-managed panes.

    303 GitHub stars~1.7k tokensUpdated 2 mo ago
    DevelopmentAuto-check passed
  • Commit

    Happenmass/omux

    Structured git commits with conventional format. An agent skill from Happenmass/omux.

    102 GitHub stars~224 tokensUpdated 2 mo ago
    DevelopmentAuto-check passed
  • Project Session Manager

    Yeachan-Heo/oh-my-claudecode

    Creates isolated git worktrees, with optional tmux sessions, for PR reviews, issue fixes and feature work across projects and repositories.

    40k GitHub stars~4k tokensUpdated 3 days ago
    DevelopmentAuto-check passed
  • MUST be considered at task start in this repository to detect OpenSpec change lifecycle work and route Qwen Code review tasks without loading unnecessary context.

    143 GitHub stars~923 tokensUpdated today
    DevelopmentAuto-check passed
  • Design optimal agent team compositions with sizing heuristics, preset configurations, and agent type selection.

    40k GitHub stars~2k tokensUpdated 6 days ago
    DevelopmentAuto-check passed

More from QwenLM/qwen-code

All 41 skills in this repo
  • Qwen Code E2E Testing

    QwenLM/qwen-code

    Guides end-to-end testing of the Qwen Code CLI in headless mode with real model calls, MCP test servers and inspection of raw API traffic.

    28k GitHub stars~2.1k tokensUpdated today
    Auto-check passed
  • Scheduled CI skill that scans a repository for small, certain docs, test and code hygiene issues and fixes them on one branch with a commit per finding.

    28k GitHub stars~1.7k tokensUpdated today
    Auto-check passed
  • Builds a rebranded Qwen Code desktop package from the Tauri shell using only a brand id and a logo, with sensible derived defaults.

    28k GitHub stars~2.1k tokensUpdated today
    Auto-check passed
  • Walks through capturing and comparing V8 heap snapshots to find memory leaks in the Qwen Code Node.js CLI, using tmux and the chrome-devtools CLI.

    28k GitHub stars~1.3k tokensUpdated today
    Auto-check passed
  • tmux Real User Testing

    QwenLM/qwen-code

    Drives Qwen Code in a real tmux session the way a user would and saves a readable step-by-step transcript of each screen for maintainers to review.

    28k GitHub stars~2.3k tokensUpdated today
    Auto-check passed
  • Agent Reproduce Align

    QwenLM/qwen-code

    Runs a reference agent (Codex or Claude Code) and Qwen Code on the same scenario, captures HTTP and terminal traces, and compares them until behavior matches.

    28k GitHub stars~1.1k tokensUpdated today
    Auto-check passed

Works with

Questions about Agent Feature Reproduction

What does Agent Feature Reproduction do?

Reproduces a feature from Codex or Claude Code in Qwen Code by running the reference agent under capture, reading the traces, then implementing matching behavior. Your current session serves as the test harness here, and a nested reference agent, either Codex or Claude Code, runs as the program under test. The skill asks once which reference to use if you have not said, discovers the local launch command rather than assuming it, and defines the feature in one sentence together with a minimal prompt that triggers it.

When should I use Agent Feature Reproduction?

Agent Feature Reproduction fits situations like: cloning a slash command or UI behavior from Codex into Qwen Code; capturing the request bodies and tool schemas another agent sends; recording a terminal-visible feature of Claude Code to match it elsewhere.

How do I install Agent Feature Reproduction in Claude Code?

Run `npx skills add QwenLM/qwen-code --skill agent-reproduce-feature -a claude-code`. Or copy the skill folder (.qwen/skills/agent-reproduce-feature in QwenLM/qwen-code) into .claude/skills/agent-reproduce-feature in your project. Claude Code loads it when a task matches its description.

How do I install Agent Feature Reproduction in Codex?

Run `npx skills add QwenLM/qwen-code --skill agent-reproduce-feature -a codex`. Or copy the skill folder (.qwen/skills/agent-reproduce-feature in QwenLM/qwen-code) into .agents/skills/agent-reproduce-feature in your project. Codex loads it when a task matches its description.

Can I use Agent Feature Reproduction in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add QwenLM/qwen-code --skill agent-reproduce-feature -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/agent-reproduce-feature, .gemini/skills/agent-reproduce-feature, .github/skills/agent-reproduce-feature and .opencode/skills/agent-reproduce-feature in your project.

What does Agent Feature Reproduction need to run?

Going by SKILL.md and its folder, Agent Feature Reproduction needs Python and a shell for the scripts in its folder and the command-line tools its instructions call (claude and codex). Our summary lists: Codex or Claude Code installed locally as the reference agent; tmux, for terminal capture; Python and a MITM capture setup for the bundled scripts.

Does Agent Feature Reproduction access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Agent Feature Reproduction safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Agent Feature Reproduction use?

Agent Feature Reproduction is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Agent Feature Reproduction use?

About 1.5k tokens (SKILL.md is roughly 5.8k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 1.3k tokens, read only when the agent opens those files.

What are the alternatives to Agent Feature Reproduction?

Skills that share tags, products or a category with Agent Feature Reproduction: Deep Review (dyad-sh/dyad, 22k stars), Mori Agent Bridge (vaayne/mori, 303 stars), Commit (Happenmass/omux, 102 stars) and Project Session Manager (Yeachan-Heo/oh-my-claudecode, 40k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Agent Feature Reproduction?

QwenLM (a GitHub organization) maintains it in QwenLM/qwen-code, which has 28,410 GitHub stars. The repository holds 41 skills in this directory. The repository was last updated on October 11, 2026.

Source: QwenLM/qwen-code on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.