Skip to main content
skill CX Codex

mise — skill for Claude Code and Codex: tool versions and task running

A skill for Claude Code, Codex, Cursor and other platforms that teaches the agent to work with mise, the polyglot tool version manager, environment variable manager, and task runner.

MIT 133 installs ★ 29 updated 2026-08-17

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add oakoss/agent-skills --skill mise -a claude-code
Open on GitHub

What mise does

The skill gives the agent a working model of mise's version resolution chain: MISE_<TOOL>_VERSION takes highest priority, then mise.toml in the current directory, then parent directories, with .nvmrc and .python-version read last for backward compatibility.

With it loaded, the agent can pin versions via mise use node@22, define tasks with depends arrays for prerequisite ordering, set sources and outputs for incremental skipping and watch mode, and wire in dotenv files through _.file inside an [env] block. Backends like npm:prettier, cargo:cargo-machete, pipx:, and GitHub Releases let the agent install tools without reaching for separate package managers.

The skill also carries the constraint that secrets must not go into mise.toml itself — they belong in .env.local, gitignored — and that mise activate is wrong for CI scripts, where mise exec or eval "$(mise env)" is the right path.

What it helps with

  • Pin Node, Python, Rust, Go and Java versions in one per-project file
  • Replace a Makefile with mise.toml tasks that have dependencies and watch mode
  • Migrate a project from asdf or nvm while keeping .tool-versions working
  • Set environment variables per directory without a separate direnv install
  • Configure incremental builds using sources and outputs on a task

Example prompts for the agent

  • Pin Node 22 and Python 3.12 in the current project's mise.toml
  • Define a build task in mise.toml that depends on lint and skips when src/** hasn't changed
  • Convert the existing Makefile targets to mise.toml tasks with depends and load secrets from .env.local via _.file

How to install mise

1Skills CLI (Vercel)

npx skills add oakoss/agent-skills --skill mise -a claude-code

2Manually: put the files in place

~/.claude/skills/mise/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/mise/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about mise

How do I install the mise skill in Claude Code?

Run npx skills add oakoss/agent-skills --skill mise -a claude-code. The skill file will be placed at ~/.claude/skills/mise/SKILL.md.

What does the mise skill actually do for the agent?

It gives the agent knowledge of mise commands for installing and pinning tool versions, writing task definitions with dependencies and incremental builds, loading dotenv files, and using npm, cargo, pipx, and GitHub Release backends.

Does the skill handle projects that still use asdf's .tool-versions?

Yes. Mise reads .tool-versions as a lower-priority source in its resolution chain, so the agent can work with existing asdf configs and guide a gradual migration to mise.toml rather than a forced rewrite.

Source text

SKILL.md · MIT
---
name: mise
description: |
  Mise (formerly rtx) polyglot tool version manager, environment variable manager, and task runner. Covers tool version management (install, use, pin across Node/Python/Rust/Go/Java and more), mise.toml task definitions (scripts, dependencies, watch mode, incremental builds), environment variable management (.env integration, per-directory env, redaction), project-level tool pinning, backend system (asdf, npm, pipx, cargo, GitHub releases), and comparison with alternatives (asdf, nvm, pyenv, Makefiles).

  Use when configuring development tool versions, defining project tasks in mise.toml, managing per-project environment variables, setting up polyglot dev environments, migrating from asdf or nvm, or automating build/test/lint/deploy workflows with mise run.
license: MIT
metadata:
  author: oakoss
  version: '1.0'
  source: 'https://mise.jdx.dev'
user-invocable: false
---

# Mise

## Overview

Mise is a **polyglot development tool manager** that handles tool versions, environment variables, and task running in a single CLI. It replaces asdf, nvm, pyenv, direnv, and Makefiles with a unified `mise.toml` configuration per project.

**When to use:** Managing multiple language runtimes per project, defining reproducible dev environments, running project tasks with dependencies, replacing scattered `.nvmrc`/`.python-version`/`.tool-versions` files, automating CI pipelines.

**When NOT to use:** Container-only workflows where all tools live in Docker images, single-language projects already well-served by their native version manager, production runtime management (mise is a dev tool).

## Version Resolution Order

Mise resolves tool versions by checking these sources in priority order:

1. `MISE_<TOOL>_VERSION` environment variable
2. `mise.toml` in current directory
3. `mise.toml` in parent directories (walks up the tree)
4. `.tool-versions` file (asdf compatibility)
5. Legacy files (`.nvmrc`, `.python-version`, `.ruby-version`)
6. `~/.config/mise/config.toml` (global default)

## Quick Reference

| Pattern               | Command / Config                           | Key Points                                  |
| --------------------- | ------------------------------------------ | ------------------------------------------- |
| Install tools         | `mise install`                             | Reads mise.toml, installs all listed tools  |
| Pin tool version      | `mise use node@22`                         | Writes to mise.toml in current directory    |
| Pin globally          | `mise use -g node@22`                      | Writes to ~/.config/mise/config.toml        |
| Run a task            | `mise run build`                           | Runs task defined in mise.toml              |
| Run with args         | `mise run test -- --watch`                 | Passes args after `--` to the task          |
| Watch mode            | `mise watch build`                         | Re-runs task when sources change            |
| List tasks            | `mise tasks`                               | Shows all available tasks                   |
| Set env vars          | `[env]` section in mise.toml               | Per-directory, auto-activated on cd         |
| Load .env file        | `_.file = ".env"`                          | Loads dotenv into environment               |
| Extend PATH           | `_.path = ["./bin"]`                       | Prepends directories to PATH                |
| List installed        | `mise ls`                                  | Shows all installed tool versions           |
| Outdated tools        | `mise outdated`                            | Shows tools with newer versions             |
| Upgrade tools         | `mise upgrade`                             | Upgrades tools to latest within constraints |
| Trust config          | `mise trust`                               | Trusts mise.toml in current directory       |
| Tool backends         | `"npm:prettier"` / `"cargo:cargo-machete"` | Install from npm, cargo, pipx, GitHub, etc. |
| Task dependencies     | `depends = ["lint", "test"]`               | Prerequisite tasks run first                |
| Incremental build     | `sources` + `outputs` on task              | Skips task if outputs newer than sources    |
| Exec without activate | `mise exec -- node app.js`                 | Runs command with mise-managed tools        |
| Diagnostics           | `mise doctor`                              | Check installation and config health        |
| Prune unused          | `mise prune`                               | Remove tool versions not in any config      |
| Generate hook         | `mise generate git-pre-commit`             | Generate git pre-commit hook for tasks      |
| Env-specific config   | `.mise.staging.toml`                       | Activated via `MISE_ENV=staging`            |
| Shims for IDEs        | `mise settings set shims_on_path true`     | PATH-based shims for IDE compatibility      |

## Common Mistakes

| Mistake                                          | Correct Pattern                                                      |
| ------------------------------------------------ | -------------------------------------------------------------------- |
| Using `mise install node@22` without `mise use`  | `mise use node@22` both installs and pins to mise.toml               |
| Editing `.tool-versions` manually with mise      | Use `mise use` to update; mise.toml is preferred over .tool-versions |
| Forgetting `mise trust` on new project clone     | Run `mise trust` to activate untrusted config files                  |
| Using `depends` key for task dependencies        | Current key is `depends` (array), not `deps`                         |
| Running `mise run` without activating mise       | Run `mise activate` in shell profile or use `mise exec`              |
| Putting secrets directly in mise.toml            | Use `_.file = ".env.local"` and gitignore the .env file              |
| Expecting env vars without `cd`-ing into project | Mise activates env on directory change; use `mise env` to debug      |
| Using `latest` version in shared projects        | Pin specific major versions (`node = "22"`) for reproducibility      |
| Defining tasks in Makefile alongside mise        | Consolidate all tasks in mise.toml for one tool                      |
| Missing shebang in multi-line task scripts       | Add `#!/usr/bin/env bash` for explicit interpreter                   |
| Not using `sources`/`outputs` for slow tasks     | Define source globs for incremental skipping and watch mode          |
| Using `mise activate` in non-interactive scripts | Use `mise exec` or `eval "$(mise env)"` in scripts and CI            |

## Delegation

- **Task pattern discovery**: Use `Explore` agent
- **Configuration review**: Use `Task` agent
- **CI pipeline integration**: Use `Task` agent

> If the `rust` skill is available, delegate Rust toolchain management patterns to it.
> If the `python-uv` skill is available, delegate Python version and virtual environment patterns to it.
> If the `github-actions` skill is available, delegate CI workflow patterns to it.
> If the `docker` skill is available, delegate containerized workflow patterns to it.
> If the `pino-logging` skill is available, delegate logging configuration patterns to it.
> If the `sentry` skill is available, delegate error monitoring setup patterns to it.

## References

- [Tool version management and backends](references/tool-management.md)
- [Task definitions, dependencies, and scripts](references/task-runner.md)
- [Environment variables and dotenv integration](references/environment-variables.md)
- [Configuration files and settings](references/configuration.md)
- [Common task patterns for projects](references/task-patterns.md)
- [Migration from asdf, nvm, and alternatives](references/migration.md)

© oakoss · MIT · oakoss/agent-skills

Similar skills

All skills for DevOps and infrastructure →

From the same set106

The whole set →
tanstack-db Get guidance on TanStack DB collections, live queries, and optimistic writes. Useful when a UI needs reactive local data or explicit sync with a backend. CX Codex +1 136installs prompt-engineering prompt-engineering is a Claude Code skill for prompt design, covering reasoning chains, ReAct loops, system prompt layouts, extended thinking and context trimming. CX Codex +1 135installs react-error-handling react-error-handling guides agents on React error boundaries and fallback interfaces to prevent component rendering failures from crashing the whole page. CX Codex +1 134installs frontend-builder The frontend-builder skill guides React and Next.js UI work, from component structure to forms and error handling. Use it when starting a web app or deciding how its frontend should be organized. CX Codex +1 134installs data-visualizer data-visualizer guides chart and dashboard development using Recharts, Chart.js, or D3.js with built-in accessibility rules. CX Codex +1 133installs knowledge-base-manager knowledge-base-manager is a Claude Code skill for choosing a document, graph, or hybrid knowledge-base design and planning its maintenance. It covers content curation, quality checks, and versioning. CX Codex +1 131installs secure-ai secure-ai — a skill that hardens the LLM layer of an app: injection defense, output validation, and zero-trust rules for agents that call tools. CX Codex +1 130installs python-uv python-uv teaches coding agents to manage Python projects with uv: initialization, dependencies, lockfiles, workspaces, and packaging. Useful when migrating from pip and poetry workflows. CX Codex +1 129installs

Project sponsors

Companies that keep this analytics open