vx-usage

Files (1)

• SKILL.md

SKILL.md (first lines)

# VX - Universal Development Tool Manager

> **One-sentence summary**: vx = prefix any dev tool command with `vx` → it auto-installs the tool and runs it.

vx is a universal development tool manager that automatically installs and manages
development tools (Node.js, Python/uv, Go, Rust, etc.) with zero configuration.

## Core Concept

Instead of requiring users to manually install tools, prefix any command with `vx`:

```bash
vx node --version      # Auto-installs Node.js if needed
vx uv pip install x    # Auto-installs uv if needed
vx go build .          # Auto-installs Go if needed
vx cargo build         # Auto-installs Rust if needed
vx just test           # Auto-installs just if needed
```

vx is fully transparent - same commands, same arguments, just add `vx` prefix.

## Essential Commands

### Tool Execution (most common)
```bash
vx <tool> [args...]           # Run any tool (auto-installs if missing)
vx node app.js                # Run Node.js
vx python script.py           # Run Python (via uv)
vx npm install                # Run npm
vx npx create-react-app app   # Run npx
vx cargo test                 # Run cargo
vx just build                 # Run just (task runner)
vx git status                 # Run git
vx gh pr status               # Run GitHub CLI
```

### Git and GitHub for Codex

When Codex or another AI agent works in a vx-managed repository, use vx-managed
Git and GitHub CLI commands. Do not run bare `git` or bare `gh`.

```bash
vx git status --short --branch
vx git fetch origin main
vx git checkout -B fix/example origin/main
vx git diff --stat
vx git add path/to/file
vx git commit -m "fix: example"

vx gh issue view 123
vx gh pr view 456 --json title,state,headRefName
vx gh pr checks 456
vx gh run view 789 --json status,conclusion,jobs
```

### Token-Efficient Agent Workflows

vx is not just an installation wrapper. For agents, it is the stable way to use
fast search, structured GitHub queries, JSON filters, and scoped diffs without
spending tokens on irrelevant output.

Prefer narrow, structured commands before broad dumps:

```bash
# Search and file discovery
vx rg -n --glob '!target/**' --glob '!node_modules/**' "OutputRenderer"
vx rg --files -g '*.rs' -g '!target/**'
vx fd provider.star crates/vx-providers

# Git context with small output first
vx git status --short --branch
vx git diff --stat
vx git diff --name-only origin/main...HEAD
vx git grep -n "CommandOutput" origin/main -- crates/vx-cli

# GitHub context with selected fields
vx gh issue view 123 --json title,state,labels,body
vx gh pr view 456 --json title,state,headRefName,baseRefName,files
vx gh pr checks 456 --json name,state,conclusion,link
vx gh run view 789 --json status,conclusion,jobs
vx gh run view 789 --json jobs --jq '.jobs[] | {name,conclusion,startedAt,completedAt}'
vx gh run view 789 --log | vx rg -n -m 80 "error|failed|panic|Traceback|warning"

# Structured filtering
vx jq -r '.files[].path' pr.json
vx yq '.jobs | keys' .github/workflows/ci.yml
```

Token-saving defaults for agents:
- Start with `vx rg`, `vx fd`, `vx git diff --stat`, and `vx git diff --name-only`; open full files or full diffs only after locating the relevant surface.
- Use `vx gh --json ...` with selected fields, and add `--jq` when a small projection is enough.
- Use vx structured output flags when the vx command supports them: `--json`, `--fields`, `--toon`, `--compact`, or `--output-format toon|compact`.
- For forwarded runtimes like `vx node`, `vx cargo`, or `vx npm`, use that tool's own quiet, JSON, or filtering flags when available.
- Pipe large logs through vx-managed filters such as `vx rg`, `vx jq`, or `vx yq` before reading them.
- Use `vx --compact <tool> ...` only when you still need broad subprocess output after structured fields and grep-style filters are not enough. It preserves vx transparency unless explicitly requested.
- Do not expect default `vx git` or `vx gh` forwarding to shrink output; explicit `--json`, `--jq`, filtering, or `--compact` is what saves tokens.

Compression decision tree for CI/log triage:
1. Status only: `vx gh run view <run> --json status,conclusion,jobs --jq '.jobs[] | {name,conclusion}'`.
2. Suspected failure: `vx gh run view <run> --log | vx rg -n -m 80 "error|failed|panic|Traceback|FAILED|warning"`.
3. Broad but bounded context: `vx --compact gh run view <run> --log`.
4. Last resort: full raw logs, preferably saved to a file and searched locally before being pasted into an agent prompt.

Observed on a successful 5,589-line GitHub Actions run: selected `gh --json --jq`
projection was about 500 tokens, raw `gh --log` output was about 226k tokens,
and `vx --compact gh --log` was about 15.9k tokens. That makes semantic
selection the default, compact mode the fallback for broad context, and raw logs
the exception.

### Agent Operating Principles

vx skills should help agents make small, correct, maintainable changes with
bounded context. Treat vx as a token-aware execution layer, not just a command
prefix.

Use this loop for coding tasks:
1. Inspect the narrowest relevant file, symbol, diff, log, or test output first.
2. Prefer existing project patterns over new helpers or abstractions.
3. Make the smallest maintainable change that solves the actual request.

From dcc-mcp/dcc-mcp-3dsmax, MIT.

More from dcc-mcp/dcc-mcp-3dsmax