New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Reproduce Issue

by nrwl in nrwl/nx

The single skill for reproducing an nx issue. An agent skill from nrwl/nx.

MITAuto-check: notesDevOps & Cloud

Install Reproduce Issue

skills CLI
$ npx skills add nrwl/nx --skill reproduce-issue -a claude-code

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

GitHub CLI
$ gh skill install nrwl/nx reproduce-issue --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/nrwl/nx.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/reproduce-issue .claude/skills/reproduce-issue && 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
reproduce-issue
GitHub stars
29k
Token cost
~2.6k tokens
SKILL.md length
855 words
Files
1
Skills in repo
21
Repo updated
First seen
Licence
MIT

At a glance

The single skill for reproducing an nx issue. An agent skill from nrwl/nx.

  • Works in 3 steps: Fetch the issue → Extract from the body: the repro repo… → Fill the parameters below and run the…
  • Tasks that involve Containers
  • SKILL.md covers Entry A — a GitHub issue…, Entry B — explicit parameters…, Platform (where the sandbox… and Preflight — check the…, plus 5 more sections
  • Calls docker, git and pnpm; reaches registry.npmjs.org

What it does

Reproduce Issue is an agent skill from nrwl/nx. The single skill for reproducing an nx issue. Given a GitHub issue number (human entry) OR explicit repro parameters (agent entry), it runs the reproduction ENTIRELY inside an isolated Docker sandbox — gVisor on Linux, the Docker VM on macOS — so the untrusted repro's install scripts and commands never execute on the host, then reports whether it reproduces. Called by humans via "/reproduce-issue

Its SKILL.md is about 2.6k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in DevOps & Cloud, covering Containers. It works with Docker, GitHub, Linux and macOS. The repository describes itself as: The Monorepo Platform that amplifies both developers and AI agents. Nx optimizes your builds, scales your CI, and fixes failed PRs automatically. Ship in half the time. The licence is MIT.

When your agent uses it

  • Tasks that involve Containers

Example prompts

  • “/reproduce-issue”

Requirements

  • Node.js
  • Docker
  • Pre-approved tools (allowed-tools): Read, Grep, Glob, Bash(uname *), Bash(gh issue view *), Bash(gh issue list *), Bash(docker run *), Bash(docker cp *), Bash(docker rm *), Bash(docker info *), Bash(docker pull *)

Workflow steps

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

  1. Fetch the issue
  2. Extract from the body: the repro repo URL (or create-nx-workspace steps), the exact command(s) that show the bug, the reported vs expected…
  3. Fill the parameters below and run the sandbox (default nx-version = whatever the issue reports / the repo pins; default registry = public…

What it can do on your machine

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

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Grep
    • Glob
    • Bash(uname *)
    • Bash(gh issue view *)
    • Bash(gh issue list *)
    • Bash(docker run *)
    • Bash(docker cp *)
    • Bash(docker rm *)
    • Bash(docker info *)

    …and 1 more on the same allowed-tools line.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • docker
    • git
    • pnpm
    • node
    • gh
    • npm
    • mise
    • bash

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

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • registry.npmjs.org

    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

Reproduce Issue loads about 2.6k tokens when it runs. Until then it costs about 104 tokens; SKILL.md has 855 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~104
When it runs · the whole SKILL.md, loaded when a task matches
~2.6k

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: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NoteRuns commands with sudoSKILL.md:53
    Miss → Linux: `sudo systemctl start docker`. macOS: `colima start` (or open Docker Desktop). Or run `setup-review-san
  • NoteRuns commands with sudoSKILL.md:62
    el update left `veth` unloadable). Fix: `sudo modprobe veth`; if that errors with a BTF/version mismatch, **reboot** (th

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); files beside SKILL.md are not scanned.

SKILL.md

The full file from nrwl/nx at commit 200edc8, republished under its MIT licence (© nrwl). 855 words, ~2,617 tokens.

Download SKILL.mdSave it as .claude/skills/reproduce-issue/SKILL.md (or your agent's skills folder).
name
reproduce-issue
description
The single skill for reproducing an nx issue. Given a GitHub issue number (human entry) OR explicit repro parameters (agent entry), it runs the reproduction ENTIRELY inside an isolated Docker sandbox — gVisor on Linux, the Docker VM on macOS — so the untrusted repro's install scripts and commands never execute on the host, then reports whether it reproduces. Called by humans via "/reproduce-issue
allowed-tools
Read, Grep, Glob, Bash(uname *), Bash(gh issue view *), Bash(gh issue list *), Bash(docker run *), Bash(docker cp *), Bash(docker rm *), Bash(docker info *), Bash(docker pull *)

Reproduce an issue (sandboxed)

Reproduce an nx bug entirely inside an isolated container and report the outcome. The untrusted repro — its install (arbitrary postinstall scripts) and its repro command — runs only in the sandbox, never on the host. --rm destroys everything on exit; nothing touches the host filesystem.

This is the one reproduction engine in the repo. It has two front doors:

Entry A — a GitHub issue (human: /reproduce-issue <N>)

  1. Fetch the issue:
    bash
    gh issue view <N> --repo nrwl/nx --json number,title,body,comments,labels
  2. Extract from the body: the repro repo URL (or create-nx-workspace steps), the exact command(s) that show the bug, the reported vs expected behavior, and the Nx Report (nx version + Node version).
  3. Fill the parameters below and run the sandbox (default nx-version = whatever the issue reports / the repo pins; default registry = public npm).

Entry B — explicit parameters (agent: reproduce-verifier Level 2)

The caller passes these directly:

  • repro — repo:<git-url> (clone a public repo) OR create:"<create-nx-workspace args>".
  • nx-version:<version> — install this published nx and rewrite the repro's nx / @nx/* / @nrwl/* deps to it. For reproducing against a released version.
  • nx-build:<git-ref> (PR-verification mode) — instead of a published version, build nx from this nrwl/nx commit inside the sandbox and reproduce against it. Uses the nx-review-sandbox image; the skill derives the version and serves it from a localhost verdaccio in the same container. Mutually exclusive with nx-version.
  • nx-registry:<url> (optional, nx-version mode only) — registry to install from. Default public npm.
  • command:"<repro-cmd>" — the command whose output/exit code decides the verdict.
  • node-image:<img> (optional) — base image matching the issue's Node (default node:22; public images are multi-arch → native on Apple Silicon).
  • expect:<reported symptom> (optional), setup:"<files/steps>" (optional) — files to create in the workspace first.

Platform (where the sandbox boundary comes from)

Run uname -s once:

  • Linux → add --runtime=runsc to docker run (gVisor is the sandbox).
  • macOS (Darwin) → omit --runtime=runsc (the Docker VM is the sandbox). Verify docker info works; if not, tell the user to colima start (or start Docker Desktop / OrbStack).

The command below shows the Linux form — on macOS drop --runtime=runsc, keep the rest.

Preflight — check the environment, fail with a FIX (not a mystery)

Before running anything, verify prerequisites in order and stop at the first miss, printing the one-line fix. Most misses point at the setup-review-sandbox skill, which installs/builds everything.

  1. Docker is up:

    bash
    docker info >/dev/null 2>&1 && echo up || echo MISSING

    Miss → Linux: sudo systemctl start docker. macOS: colima start (or open Docker Desktop). Or run setup-review-sandbox.

  2. Container networking works (the check that would have caught the veth breakage):

    bash
    docker run --rm --network none alpine true   # A: is the sandbox itself OK?
docker run --rm alpine true                  # B: is networking OK?

    If A passes but B fails with veth ... operation not supported → networking is broken (usually a kernel update left veth unloadable). Fix: sudo modprobe veth; if that errors with a BTF/version mismatch, reboot (the running kernel no longer matches its modules).

  3. Isolation runtime (platform-specific):

    • Linux — gVisor registered as a Docker runtime?
      bash
      docker info --format '{{range $k,$v := .Runtimes}}{{$k}} {{end}}' | grep -q runsc && echo ok || echo MISSING
      Miss → run setup-review-sandbox (installs + registers runsc).
    • macOS — the Docker VM (Colima / Docker Desktop) is the sandbox; step 1 already covered it. No runsc.

  4. (PR-build mode ONLY) the toolchain image exists:

    bash
    docker image inspect nx-review-sandbox:latest >/dev/null 2>&1 && echo ok || echo MISSING

    Miss → run setup-review-sandbox (builds it from tools/review-sandbox/Dockerfile). Skip this check when reproducing against a published nx version — that path needs only steps 1–3 and a public node image.

If all needed checks pass, proceed.

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

Safety rails (do NOT break these)

  • The untrusted repro runs only in the container. Never -v a host path in. nx comes from a registry (or docker cp-ed tarballs), never a mount.
  • Always pass: --cap-drop ALL, --security-opt no-new-privileges, --memory 4g --cpus 4 --pids-limit 2048, --rm; plus --runtime=runsc on Linux.
  • Network is ON (clone + install need it). gVisor still protects the host kernel; on macOS the VM protects the host.
  • One docker command per Bash call. (Chaining inside the container's bash -c '...' is one host command, which is fine.)

Run

Detect platform, then a single host command does clone/create → dep-rewrite → install → repro, all inside the sandbox:

bash
# RUNTIME="--runtime=runsc"   on Linux
# RUNTIME=""                   on macOS
docker run --rm $RUNTIME \
  --cap-drop ALL --security-opt no-new-privileges \
  --memory 4g --cpus 4 --pids-limit 2048 \
  node:22 bash -c '
    set -e
    git clone --depth 1 <GIT_URL> /repro          # repo: form
    # -- or -- npx --yes create-nx-workspace <ARGS> --directory /repro   # create: form
    cd /repro

    node -e '"'"'
      const fs=require("fs"),p=JSON.parse(fs.readFileSync("package.json","utf8")),v=process.argv[1];
      for (const s of ["dependencies","devDependencies"]) for (const n of Object.keys(p[s]||{}))
        if (n==="nx"||n.startsWith("@nx/")||n.startsWith("@nrwl/")) p[s][n]=v;
      fs.writeFileSync("package.json", JSON.stringify(p,null,2)+"\n");
    '"'"' <NX_VERSION>

    rm -f package-lock.json pnpm-lock.yaml yarn.lock
    PM=npm; test -f pnpm-workspace.yaml && PM=pnpm
    npm i -g pnpm@11 >/dev/null 2>&1 || true
    npm_config_registry=<NX_REGISTRY> $PM install

    ( timeout 300 <REPRO_COMMAND> ); echo "REPRO_EXIT=$?"
    echo "kernel: $(uname -r)"
  '

Substitute <GIT_URL>/<ARGS>, <NX_VERSION>, <NX_REGISTRY> (default https://registry.npmjs.org), and <REPRO_COMMAND>.

Classify + report

Compare output and REPRO_EXIT against the reported symptom, and return this block (verdicts match the reproduce-verifier's Level 2 vocabulary):

repro:        <repo-url | create-nx-workspace ...>
nx-version:   <version>   (registry: <url>)
command:      <verbatim>
exit code:    <N>
verdict:      <PR_REPRO_PASSES | PR_REPRO_FAILS | PR_REPRO_FAILS_DIFFERENT | PR_REPRO_INCONCLUSIVE | SETUP_FAILED>
output (tail ~20 lines):
  <...>
  • succeeded (matches the claimed fix) → PR_REPRO_PASSES
  • failed with the reported error → PR_REPRO_FAILS
  • failed with a different error → PR_REPRO_FAILS_DIFFERENT (flag for human)
  • unclear → PR_REPRO_INCONCLUSIVE
  • clone/create/install broke before the repro ran → SETUP_FAILED (say which step + tail)

(For a human /reproduce-issue run against a released version, "reproduced" vs "did not reproduce" is the plain-language answer; the verdict vocab above is for the agent.)

PR-build mode — build nx from source in the sandbox (nx-build)

When nx-build:<git-ref> is given, do everything in one nx-review-sandbox container (it carries the mise toolchain incl. java + dotnet, required by nx's @nx/dotnet/@nx/gradle graph plugins). One container, localhost throughout — no host build, no host verdaccio, no host.docker.internal, no listen-address change:

bash
# RUNTIME="--runtime=runsc"  on Linux, ""  on macOS
docker run --rm $RUNTIME \
  --cap-drop ALL --security-opt no-new-privileges \
  --memory 20g --cpus 6 --pids-limit 8192 --tmpfs /work:rw,exec,size=16g \
  -e CI=true -e NX_DAEMON=false \
  nx-review-sandbox:latest bash -c '
    set -e
    # 1. build nx from the PR commit
    cd /work
    git clone --filter=blob:none https://github.com/nrwl/nx nx && cd nx
    git checkout <GIT_REF>
    mise install && pnpm install --frozen-lockfile
    PORT=4873
    pnpm nx local-registry @nx/nx-source --port=$PORT >/tmp/verdaccio.log 2>&1 &
    for i in $(seq 1 60); do curl -sf http://localhost:$PORT/-/ping >/dev/null 2>&1 && break; sleep 1; done
    NX_LOCAL_REGISTRY_PORT=$PORT pnpm nx populate-local-registry-storage @nx/nx-source
    NXV=$(node -p "require(\"/work/nx/dist/packages/nx/package.json\").version")

    # 2. reproduce against that build — same container, localhost registry
    cd /work
    git clone --depth 1 <GIT_URL> repro     # or: npx --yes create-nx-workspace <ARGS> --directory repro
    cd repro
    # rewrite nx/@nx/@nrwl deps to "$NXV" (same node one-liner as the Run section)
    rm -f package-lock.json pnpm-lock.yaml yarn.lock
    npm_config_registry=http://localhost:$PORT pnpm install
    ( timeout 300 <REPRO_COMMAND> ); echo "REPRO_EXIT=$?"
    echo "kernel: $(uname -r)"
  '

Because verdaccio and the repro live in the same container, the registry is plain localhost — the reachability/listen-address problems a host verdaccio would create simply don't exist. Classify the result exactly as in "Classify + report".

Prerequisite: the nx-review-sandbox image (setup-review-sandbox). The nx build is heavy (~several min + several GB) — RAM-backed via the tmpfs above so it stays off the host disk.

Cleanup

--rm destroys the container and everything in it on exit. Nothing persists on the host. Stray sandbox containers/images: /sandbox-prune.

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

Files

Just SKILL.md in .claude/skills/reproduce-issue of nrwl/nx.

Open the folder on GitHubat commit 200edc8

Compare with similar skills

Reproduce Issue 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.

Reproduce Issue compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Reproduce Issue this skillnrwl/nx29k—~2.6kAutomated safety check: NotesMIT
.NET Crash Dump Collectiondotnet/skills5.6k2 repos~1.1kAutomated safety check: PassMIT
CI Adhoc Testnubjs/nub4.4k—~1.7kAutomated safety check: PassMIT
Releasing MarchatCod-e-Codes/marchat137—~801Automated safety check: PassMIT
Agentdock User Guideuvwt/agentdock1.2k—~1.6kAutomated safety check: PassApache-2.0
Cicdthun-res/vlink116—~856Automated safety check: PassApache-2.0

Similar skills

  • .NET Crash Dump Collection

    dotnet/skills

    Official

    Configures automatic crash dumps or captures dumps from running processes for modern .NET apps on Linux, macOS and Windows, including Docker and Kubernetes.

    5.6k GitHub starsUsed in 2 repos~1.1k tokens
    DevOps & CloudAuto-check passed

  • CI Adhoc Test

    nubjs/nub

    Run ad-hoc / exploratory tests on a real OS or platform via CI when the behavior CANNOT be reproduced on the local host or in Docker — macOS Seatbelt / sandbox-exec / codesigning, Windows cmd.exe /…

    4.4k GitHub stars~1.7k tokensUpdated yesterday
    DevOps & CloudAuto-check passed

  • Releasing Marchat

    Cod-e-Codes/marchat

    Prepares marchat releases: version bumps, CHANGELOG, packaging checksums, GitHub Actions release workflow, and Docker tags.

    137 GitHub stars~801 tokensUpdated 8 days ago
    DevOps & CloudAuto-check passed

  • Agentdock User Guide

    uvwt/agentdock

    当用户询问 AgentDock 是什么、如何使用、配置在哪里、不同平台或安装方式怎样修改配置并生效、如何重启或验证配置、如何发现并配置 Codex/Claude/Grok 等 Coding Agent 的 ACP，以及常见运行问题时使用；覆盖 macOS Desktop、Windows Desktop、Linux 服务、Docker 和直接运行二进制，不用于源码开发与贡献流程。

    1.2k GitHub stars~1.6k tokensUpdated today
    DevOps & CloudAuto-check passed

  • Cicd

    thun-res/vlink

    用 gh CLI 触发/查看 GitHub CI/CD:手动 dispatch 工作流 (release/coverage/docker)、查看运行状态与失败日志、重跑失败 job.

    116 GitHub stars~856 tokensUpdated 2 days ago
    DevOps & CloudAuto-check passed

  • Osx Tuning

    dimetron/pi-go

    Tune macOS resource limits and sysctls for best performance with Go development, Docker/OrbStack, and Linux VMs.

    209 GitHub stars~1.6k tokensUpdated 2 days ago
    DevOps & CloudAuto-check: notes

More from nrwl/nx

All 21 skills in this repo

  • Monitor CI

    nrwl/nx

    Monitor Nx Cloud CI pipeline and handle self-healing fixes. An agent skill from nrwl/nx.

    29k GitHub starsUsed in 6 repos~4.7k tokens
    Auto-check passed

  • Nx Import

    nrwl/nx

    Import, merge, or combine repositories into an Nx workspace using nx import.

    29k GitHub starsUsed in 6 repos~3.5k tokens
    Auto-check passed

  • Run Nx Generator

    nrwl/nx

    Run Nx generators with prioritization for workspace-plugin generators.

    29k GitHub starsUsed in 2 repos~592 tokens
    Auto-check: notes

  • Author Migration

    nrwl/nx

    Author or scope a first-party Nx migration. An agent skill from nrwl/nx.

    29k GitHub stars~12k tokensUpdated yesterday
    Auto-check: notes

  • Nx Generate

    nrwl/nx

    Generate code using nx generators. An agent skill from nrwl/nx.

    29k GitHub starsUsed in 1 repo~2.2k tokens
    Auto-check passed

  • Check Docs Style

    nrwl/nx

    Check modified Nx documentation pages against the astro-docs style guide.

    29k GitHub stars~1.3k tokensUpdated yesterday
    Auto-check passed

Works with

Categories

Questions about Reproduce Issue

What does Reproduce Issue do?

The single skill for reproducing an nx issue. An agent skill from nrwl/nx. Reproduce Issue is an agent skill from nrwl/nx. The single skill for reproducing an nx issue.

When should I use Reproduce Issue?

Reproduce Issue fits situations like: tasks that involve Containers.

How do I install Reproduce Issue in Claude Code?

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

How do I install Reproduce Issue in Codex?

Run `npx skills add nrwl/nx --skill reproduce-issue -a codex`. Or copy the skill folder (.claude/skills/reproduce-issue in nrwl/nx) into .agents/skills/reproduce-issue in your project. Codex loads it when a task matches its description.

Can I use Reproduce Issue 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 nrwl/nx --skill reproduce-issue -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/reproduce-issue, .gemini/skills/reproduce-issue, .github/skills/reproduce-issue and .opencode/skills/reproduce-issue in your project.

What does Reproduce Issue need to run?

Going by SKILL.md and its folder, Reproduce Issue needs the command-line tools its instructions call (docker, git, pnpm, node, gh and npm). Our summary lists: Node.js; Docker. Its frontmatter pre-approves these tools: Read, Grep, Glob, Bash(uname *), Bash(gh issue view *), Bash(gh issue list *), Bash(docker run *), Bash(docker cp *), Bash(docker rm *), Bash(docker info *), Bash(docker pull *).

Does Reproduce Issue access the network?

SKILL.md names 1 domain. In commands or code: registry.npmjs.org; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is Reproduce Issue safe to install?

Our automated static check of SKILL.md found notes only (runs commands with sudo), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Reproduce Issue use?

Reproduce Issue is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Reproduce Issue use?

About 2.6k tokens (SKILL.md is roughly 10k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Reproduce Issue?

Skills that share tags, products or a category with Reproduce Issue: .NET Crash Dump Collection (dotnet/skills, 5.6k stars), CI Adhoc Test (nubjs/nub, 4.4k stars), Releasing Marchat (Cod-e-Codes/marchat, 137 stars) and Agentdock User Guide (uvwt/agentdock, 1.2k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Reproduce Issue?

nrwl (a GitHub organization) maintains it in nrwl/nx, which has 29,401 GitHub stars. The repository holds 21 skills in this directory. The repository was last updated on October 10, 2026.

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