Claude Code for mise Development (2026)

Why Claude Code for mise

mise (formerly rtx) replaces asdf, nvm, pyenv, rbenv, direnv, and Make with a single tool that manages language runtimes, environment variables, and project tasks. It activates the correct Node.js, Python, Go, and Rust versions when you enter a project directory and provides a task runner that replaces simple Makefiles. The challenge is configuring mise for polyglot projects that need multiple runtimes, per-environment secrets, and team-standardized tasks without conflicts.

Claude Code generates mise.toml configurations that pin exact tool versions, set up environment-specific variables, define project tasks that replace Makefiles, and configure IDE integration for seamless developer onboarding.

The Workflow

Step 1: Install mise

# Install mise
brew install mise  # macOS
# or: curl https://mise.run | sh
# Activate in shell
echo 'eval "$(mise activate zsh)"' >> ~/.zshrc
source ~/.zshrc
# Verify
mise --version

Step 2: Configure Project Environment

# mise.toml — Complete project configuration
[env]
# Project-wide environment variables
NODE_ENV = "development"
LOG_LEVEL = "debug"
DATABASE_URL = "postgresql://localhost:5432/myapp_dev"
REDIS_URL = "redis://localhost:6379"
# Template-based values
_.path = ["./node_modules/.bin", "./scripts"]
_.source = [".env.local"]  # Load additional env from file
[tools]
# Pin exact versions for reproducibility
node = "20.18.0"
python = "3.12.7"
go = "1.22.5"
rust = "1.82.0"
# Additional tools
pnpm = "9.12.0"
terraform = "1.9.8"
awscli = "2.22.0"
jq = "1.7.1"
ripgrep = "14.1.1"
# Override per-directory
[tools.python]
version = "3.12.7"
virtualenv = ".venv"  # Auto-create and activate venv
[tasks.setup]
description = "Initial project setup"
run = """
pnpm install
python -m pip install -r requirements.txt
docker compose up -d postgres redis
pnpm run db:migrate
echo "Setup complete!"
"""
[tasks.dev]
description = "Start development servers"
run = """
mise run dev:api & mise run dev:web & wait
"""
[tasks."dev:api"]
description = "Start API server"
dir = "services/api"
run = "go run ./cmd/server"
env = { PORT = "8080" }
[tasks."dev:web"]
description = "Start web frontend"
dir = "apps/web"
run = "pnpm dev"
env = { PORT = "3000" }
[tasks.test]
description = "Run all tests"
run = """
echo "=== Go tests ==="
cd services/api && go test ./... -count=1
echo "=== Python tests ==="
cd python && python -m pytest -q
echo "=== JS tests ==="
pnpm test
"""
[tasks.lint]
description = "Lint all code"
run = """
cd services/api && golangci-lint run
cd python && ruff check .
pnpm biome ci .
"""
[tasks.build]
description = "Build all services"
depends = ["lint", "test"]
run = """
cd services/api && go build -o bin/api ./cmd/server
cd apps/web && pnpm build
"""
[tasks."db:migrate"]
description = "Run database migrations"
run = "cd services/api && go run ./cmd/migrate up"
[tasks."db:reset"]
description = "Reset database (DESTRUCTIVE)"
run = """
dropdb --if-exists myapp_dev
createdb myapp_dev
mise run db:migrate
echo "Database reset complete"
"""
[tasks.clean]
description = "Clean build artifacts"
run = """
rm -rf services/api/bin
rm -rf apps/web/.next apps/web/dist
rm -rf python/.venv
find . -name '__pycache__' -exec rm -rf {} +
echo "Clean complete"
"""

Step 3: Environment-Specific Overrides

# mise.staging.toml — Staging overrides
[env]
NODE_ENV = "staging"
LOG_LEVEL = "info"
DATABASE_URL = "{{env.STAGING_DATABASE_URL}}"
[tasks."deploy:staging"]
description = "Deploy to staging"
run = """
mise run build
aws ecr get-login-password | docker login --username AWS --password-stdin $ECR_REPO
docker build -t $ECR_REPO:staging-$(git rev-parse --short HEAD) .
docker push $ECR_REPO:staging-$(git rev-parse --short HEAD)
kubectl set image deployment/api api=$ECR_REPO:staging-$(git rev-parse --short HEAD) -n staging
"""

Step 4: Verify

# Check installed tools
mise ls
# Run setup task
mise run setup
# Start development
mise run dev
# Run specific task
mise run test
# List all available tasks
mise tasks
# Check which tools would be installed
mise install --dry-run
# Trust the config file (first time in repo)
mise trust

CLAUDE.md for mise Development Environment

# mise Development Environment Standards
## Domain Rules
- mise.toml in project root (not .tool-versions for new projects)
- Pin exact versions for all tools (no ranges)
- Use tasks for all common workflows (replace Makefile)
- Task dependencies via depends = ["lint", "test"]
- Environment variables in [env] section, secrets in .env.local (gitignored)
- Per-directory tool overrides for polyglot projects
- All team members use mise (documented in CONTRIBUTING.md)
## File Patterns
- mise.toml (main configuration)
- mise.staging.toml, mise.production.toml (environment overrides)
- .env.local (secrets, gitignored)
- .mise.toml (alternative name for older versions)
## Common Commands
- mise install (install all tools)
- mise run TASK (run a task)
- mise tasks (list available tasks)
- mise ls (show installed tools)
- mise use node@20 (update tool version)
- mise trust (trust config after clone)
- mise env (show environment variables)
- mise doctor (diagnose issues)

Common Pitfalls in mise Setup

  • Forgetting mise trust on clone: mise requires explicit trust for each project’s config to prevent malicious configs from running arbitrary code. Claude Code adds mise trust to the project setup documentation and CI scripts.

  • Shell activation not configured: mise must be activated in the shell profile (.zshrc/.bashrc) to auto-switch tool versions on directory change. Claude Code verifies shell integration and adds it to onboarding documentation.

  • Python virtualenv conflicts: mise can manage Python versions and virtual environments, but conflicts with pyenv or manually created venvs. Claude Code configures mise as the sole Python version manager and sets virtualenv = ".venv" in tools.python.

Frequently Asked Questions

Do I need a paid Anthropic plan to use this?

Claude Code works with any Anthropic API plan, including the free tier. However, the free tier has lower rate limits (requests per minute and tokens per minute) that may slow down multi-step workflows. For professional use, the Build or Scale plan provides higher limits and priority access during peak hours.

How does this affect token usage and cost?

The token cost depends on the size of your prompts and Claude’s responses. Typical development tasks consume 10K-50K tokens per interaction. Using a CLAUDE.md file and skills reduces exploration tokens by 50-80%, which directly lowers costs. Monitor your usage at console.anthropic.com/settings/billing.

Can I customize this for my specific project?

Yes. All Claude Code behavior can be customized through CLAUDE.md (project rules), .claude/settings.json (permissions), and .claude/skills/ (domain knowledge). The most impactful customization is adding your project’s specific patterns, conventions, and common commands to CLAUDE.md so Claude Code follows your standards from the start.

What happens when Claude Code makes a mistake?

Claude Code creates files and edits through standard filesystem operations, so all changes are visible in git diff. If a change is wrong, revert it with git checkout -- <file> for a single file or git stash for all changes. Claude Code does not make irreversible changes unless you explicitly allow destructive commands in settings.json.

Practical Details

When working with Claude Code on this topic, keep these implementation details in mind:

Project Configuration. Your CLAUDE.md should include specific references to how your project handles this area. Include file paths, naming conventions, and any project-specific patterns that differ from defaults. Claude Code reads this file at session start and uses it to guide all operations.

Integration with Existing Tools. Claude Code works alongside your existing development tools rather than replacing them. It respects .gitignore for file visibility, uses your project’s installed dependencies, and follows the build/test scripts defined in package.json (or equivalent). Ensure your toolchain is working correctly before involving Claude Code.

Performance Considerations. For large codebases (10,000+ files), Claude Code’s file scanning can be slow if not properly scoped. Use .claudeignore to exclude generated directories (dist, build, .next, coverage) and dependency directories (node_modules, vendor). This typically reduces scan time by 80-90%.

Version Control Integration. All changes Claude Code makes are regular filesystem operations visible to git. Use git diff after each significant change to review what was modified. For experimental changes, create a branch first with git checkout -b experiment/topic so you can easily discard or keep the results.

Get started → Generate your project setup with our Project Starter.

Estimate tokens → Calculate your usage with our Token Estimator.

Try it: Estimate your monthly spend with our Cost Calculator.