claude-code-marketplace

End-to-end recipe for a modern C++ project managed by mise — cmake + ninja + ccache + mold linker + clang-tools + optional conan package manager. Full CMakePresets.json, mise.toml tasks, and first-run walkthrough. Use when starting a new C++ project or modernizing an existing one.

End-to-end recipe for a Docker-based dev loop with mise — multi-stage Dockerfile with mise pre-installed, docker-compose for services (Postgres, Redis), BuildKit cache mounts, and mise tasks that wrap compose. Use when running dev entirely in containers or prod-parity testing.

End-to-end recipe for a Go HTTP service managed by mise — Go + air (hot reload) + golangci-lint + gotestsum + a Dockerfile hint for production. Complete mise.toml template, first-run walkthrough, and common gotchas. Use when starting a new Go service or adding mise to an existing one.

End-to-end recipe for a Neovim configuration managed by mise — the vim.env.PATH prepend pattern, LSPs installed via mise (npm:pyright, aqua:gopls, etc.), conform.nvim for formatters, and the mise-managed "editor as a tool" approach. Use when setting up a modern Neovim config that plays nicely with mise-managed projects.

End-to-end recipe for a Next.js app managed by mise — Node + pnpm (via corepack) + TypeScript + Prettier + ESLint + Playwright. Complete mise.toml template, first-run walkthrough, and common gotchas. Use when starting a new Next.js app or adding mise to an existing one.

End-to-end recipe for a FastAPI service managed by mise — Python + uv + ruff + pytest + a Postgres env var. Complete mise.toml template, first-run walkthrough, and common gotchas. Use when starting a new FastAPI project or adding mise to an existing one.

End-to-end recipe for a Rails 7+ app managed by mise — Ruby + Node (for assets) + bundler with vendor/bundle + RAILS_ENV + bin/dev. Complete mise.toml template, first-run walkthrough, and common gotchas. Use when starting a new Rails app or adding mise to an existing one.

End-to-end recipe for a Terraform (or OpenTofu) IaC project managed by mise — terraform + tflint + terraform-docs + tfsec + aws-cli, with init/plan/apply/docs/lint tasks. Complete mise.toml template, first-run walkthrough, and common gotchas. Use when starting a new IaC project or adding mise to an existing one.

Go modules deep dive — workspace mode, replace directives, private modules with GOPRIVATE, vendoring vs the module cache, and when to use `go install` vs mise's go: backend. Use when working with Go module layouts or troubleshooting dependency resolution.

Go via mise — go.mod toolchain directive vs .go-version vs mise.toml precedence, GOPATH / GOBIN layout with mise, and the go: backend for installing CLIs built from source. Use when setting up Go for a project.

Node.js via mise — .nvmrc / .node-version / package.json engines auto-detection, LTS vs current, the corepack + packageManager field, and when to use the npm: backend for global CLIs. Use when setting up Node for a project or explaining how mise handles Node versions.

Node package managers — npm vs pnpm vs yarn vs bun. Why corepack + the packageManager field is the right pinning answer, when to use mise's npm: backend for global CLIs vs project-local deps, and the monorepo story. Use when picking a Node package manager or explaining corepack.

Python via mise — .python-version auto-detection, idiomatic_version_file_enable_tools, how mise compiles Python under the hood (python-build), the pre-built binaries route via MISE_PYTHON_COMPILE=0, and when to pin patch versions. Use when setting up Python for a project or troubleshooting Python installs.

Python package managers — uv vs poetry vs pipx vs pip. The rule is "mise pins python, uv/poetry manages project venv, pipx manages global CLIs". Covers the uv-first workflow (the current recommended default) and why mixing tools is the

Ruby gem management — bundler as the project-level dep manager, the vendor/bundle pattern, rubocop / standard / solargraph installation choices, and why mise's gem: backend is limited compared to aqua for Ruby CLIs that exist. Use when managing gems for a project.

Ruby via mise — .ruby-version / Gemfile ruby directive auto-detection, why system Ruby is always wrong, bundler as the gem manager on top of mise-pinned Ruby, and the OpenSSL / readline build-dep story. Use when setting up Ruby for a project.

The cargo ecosystem — cargo vs mise's cargo: backend for installing CLIs (prefer aqua over cargo build-from-source for ripgrep/fd/bat/etc.), sccache for compile caching, cargo-nextest as a test runner, cargo workspaces, and when to pin rustc exact vs channel. Use when working with cargo deps or CLIs.

Rust via mise — rust-toolchain.toml auto-detection, the mise-over-rustup architecture, channel selection (stable/beta/nightly), components (clippy, rustfmt, rust-src, rust-analyzer), and targets. Use when setting up Rust for a project or explaining how mise + rustup interact.

The direnv vs mise [env] overlap story — when mise's built-in [env] is enough to replace direnv entirely, when to keep direnv running alongside mise via the use mise integration, and how to translate common .envrc patterns to mise.toml. Use when a user is currently using direnv and wants to consolidate or coexist with mise.

Migrating from nvm to mise — reading .nvmrc, translating `nvm use` shell hooks, tearing down ~/.nvm cleanly, and handling the common bashrc/zshrc entries. Use when a user is currently using nvm and wants to adopt mise without losing their pinned Node versions.

Migrating from pyenv to mise — reading .python-version, handling pyenv-virtualenv markers, translating pyenv-installed versions, handling the compile-from-source situation, and tearing down ~/.pyenv cleanly. Use when a user is currently using pyenv and wants to adopt mise.

Migrating from rbenv to mise — reading .ruby-version, handling rbenv-gemset, preserving installed rubies, and tearing down ~/.rbenv cleanly. Use when a user is currently using rbenv and wants to adopt mise for Ruby version management.

Migrating from tfenv to mise — reading .terraform-version, translating tfenv-installed versions, handling the terraform vs tofu fork decision, and tearing down ~/.tfenv cleanly. Use when a user is currently using tfenv for Terraform version management.

Security-focused guide for AI CLI API keys — threat model, storage options (shell rc / keychain / 1Password / doppler), rotation cadence, detection of accidental plaintext leaks, and why `mise set` is never the right answer for secrets. Use when setting up or rotating keys.

The four main AI CLIs compared — Claude Code, OpenAI Codex, Google Gemini, and aichat — with provider lock-in, model-agnostic fallback strategy, and why installing all four via mise is a lightweight dev-environment win. Use when picking AI CLIs for a project.

The canonical mise.toml pattern for AI CLIs — [tools] block with aqua backends, [env] with required + redact directives, [redactions] patterns, and the ai-status task. Covers production alternatives (keychain, 1Password CLI, doppler) for environments beyond shell rc files. Use when wiring AI CLIs into a project.

clang-format, clang-tidy, clangd, and include-what-you-use — install via mise (aqua backends where possible), wire into CI, and the one-version-per-project rule. Use when setting up code quality tooling for a C++ project.

The golden trio for C++ builds — cmake + ninja + ccache. Covers ccache config (CCACHE_DIR, size, compression), ninja parallelism, CMake preset integration with mise, and the env var pattern that wires them together. Use when configuring a C++ build.

mold vs lld vs system ld — when to pick each, how to wire them via mise, and the link-time speedup for large C++ projects. Covers Linux-only mold, cross-platform lld, and Apple's ld-prime. Use when link times dominate your build loop.

Conan 2.x vs vcpkg — how to pick between them, how to integrate each with mise via [tasks], and why conan should be installed via pipx (not mise's cargo/go backends). Use when the project needs third-party C++ libraries.

The modern C++ toolchain at a glance — cmake, ninja, ccache, fast linkers (mold/lld), clang-tools, and package managers (conan/vcpkg) — with a decision framework for when to pin each via mise vs system apt/brew. Use when setting up C++ in a project for the first time.

GitHub Codespaces specifics for mise — prebuilds, repo secrets, image caching, free-tier vs paid considerations, and what goes in onCreateCommand vs postCreateCommand. Use when setting up Codespaces for a project with mise.

The full devcontainer.json schema for projects using mise — features, postCreateCommand, mounts, customizations.vscode, containerEnv, and the trust + activation patterns that the stock `mise generate devcontainer` output misses. Use when writing or reviewing a .devcontainer/devcontainer.json.

Picking the right Docker base image for mise — debian:slim vs ubuntu vs alpine (with the musl caveat) vs nvidia/cuda vs mcr.microsoft.com/devcontainers/base. Covers glibc vs musl, tool compatibility, and image-size trade-offs.

The `mise generate bootstrap -l -w` pattern for pinning mise in Dockerfiles and CI without `curl | sh`. Commit `./bin/mise` so builds are reproducible and network-free for the mise install step.

The builder → runtime multi-stage split for mise-based Dockerfiles — what to copy across stages, when mise itself belongs in the runtime stage, and how to keep the runtime image small without losing reproducibility.

The canonical patterns for running mise inside Docker — multi-stage builder/runtime split, BuildKit cache mounts for ~/.local/share/mise/installs, when mise belongs in the runtime stage, and the non-root user pattern. Use when writing a Dockerfile that installs mise or copies mise-managed tools into a container.

Cross-cutting overview of how to wire mise into every major IDE — VSCode, JetBrains, Neovim, Xcode, Zed, Sublime Text. The "if you're not sure where to start" entry point that points to per-IDE skills for depth. Use when a user says "how do I make my IDE see mise".

Wiring JetBrains IDEs (IntelliJ, PyCharm, GoLand, RubyMine, WebStorm, Android Studio) to mise using the 134130/intellij-mise plugin, plus the ~/.asdf symlink workaround for plugins that don't natively support mise yet. Covers per-language SDK selection and Gradle/Maven integration.

Wiring Neovim to mise — using vim.env.PATH to prepend the mise shims directory, handling LSP servers installed via mise vs mason.nvim, and the mise neovim cookbook pattern. Use when setting up Neovim for a project that uses mise-managed tools.