Overview of 990: Vite Is Taking Over (Vite+)
This episode explains Vite Plus (Vite+), a new unified developer toolchain built on Vite that aims to consolidate many JavaScript tooling concerns into a single, fast, opinionated, and (now) open-source experience. Hosts Scott, Wes and guest CJ walk through what Vite+ includes, how it changes developer workflows, migration behavior, current limitations (especially around framework/plugin support), and practical recommendations for adoption.
What Vite Plus is
- A unified toolchain for JavaScript projects (client-side and full‑stack).
- Initially announced with paid components but later changed to be fully open source/community-driven.
- Designed to provide a single, consistent developer UX across common tools: dev server, bundler, linter, formatter, task runner, package installer, node-version management, pre-commit hooks, caching, and more.
- Exposes a compact CLI ("vp") that abstracts away whether a project uses npm, pnpm or yarn, and provides simple commands for common tasks (vp dev, vp install, vp check, vp check --fix, vp init, vp migrate, vp env, vpx, etc.).
Key features (what it provides)
- VP CLI: short, consistent command surface for install/dev/build/check/run across projects regardless of package manager.
- Dev server & bundler: built on Vite (Vite 8 mentioned) and using a Rust-based Rollup implementation ("Rolldown") for speed.
- Fast, type-aware linting: a new linter/approach (hosts reference it as OxLint/auxlint/TS-go-lint style tooling) that is type-aware and faster than typical ESLint setups; intended to catch issues ESLint alone might miss (e.g., dropped promises).
- Fast formatter: Rust-based formatter (compatible with Prettier-style expectations) to auto-fix formatting.
- Migrate & scaffolding: vp init and vp migrate to scaffold new projects and help migrate existing ESLint/Prettier configs into Vite+ defaults (with caveats).
- Node version management: integrated node version pinning and switching so team members/CI automatically use the correct Node runtime.
- Monorepo task runner: built-in task definitions, dependency ordering, filtering (run a script for a specific package) and task orchestration across workspaces—similar in purpose to Turborepo / Nx but integrated.
- Task caching: cache output of tasks/builds to speed local and CI runs; detects unchanged inputs so unnecessary jobs are skipped.
- Binary runner: vp/ vpx-style runner (shorter than npx) for invoking binaries.
- Pre-commit hooks: built-in hooks (Husky-like) to run formatting/lint/type checks on commit.
- VS Code integration: scaffolding includes VS Code workspace files/extensions for an out-of-the-box dev setup.
How Vite+ changes developer experience
- Fewer config files / unified configuration: aim to consolidate many configs into a single Vite + VitePlus configuration (though you can still use separate files).
- Sensible defaults and opinionated choices: reduces the friction of configuring ESLint/Prettier/test runners from scratch.
- Speed: Rust-based linters/formatters + caching and efficient bundling reduce both local edit-check cycles and CI durations.
- UX niceties: short CLI (vp), auto-detect of package manager, and automatic Node version management simplify onboarding and everyday commands.
- Better agent/AI/tool compatibility: consistent project checks that agents use to validate project outputs (good for automation).
Migration & practical adoption guidance
- Best immediate fit: new projects or small projects — try Vite+ as the first scaffold before hand-crafting tooling.
- Migration: vp migrate can convert many existing configs (Prettier/ESLint) but may not migrate some tools (e.g., Biome) or framework-specific rules automatically.
- Incremental adoption recommended:
- Start using vp dev and vp install across repos for consistency.
- Adopt task runner & caching for monorepos and CI speedups.
- Gradually try linter/formatter migration on smaller repos first to evaluate results.
- Watch out for large single-commit formatting changes on migration — they can pollute git history. Consider breaking formatting changes into a deliberate commit and communicating to the team.
Current gaps & limitations (what’s not ready yet)
- Framework/plugin coverage: several frameworks (e.g., Svelte, template portions of Svelte/HTML/astro/vue) are not fully covered by Vite+ linting/formatting yet — many tools only operate on script blocks, not templates/markup.
- Ecosystem/plugin parity: some ESLint plugins and older TypeScript versioned projects may not immediately be compatible with the new type-aware linter; migrating older, pinned projects can be tricky.
- Migration completeness: the migration tools won’t translate every third-party formatter or plugin (the hosts mentioned Biome didn’t migrate automatically).
- Beta pieces: some components were called beta (formatter/linter), so expect iteration and updates.
- Risk of lock-in or partial adoption: if some teams adopt Vite+ and others keep ESLint/Prettier, you may temporarily end up with mixed toolchains during transition.
Recommendations / action items
- Try Vite+ on new projects first — least friction and greatest benefit.
- For existing projects:
- Adopt VP for run/install/dev commands and node version pinning early.
- Use vp migrate in a branch and review the formatting diff carefully; commit formatting changes separately.
- Migrate linting only after confirming framework/plugin coverage (e.g., Svelte template linting may still need existing tools).
- Use the built-in task runner and caching to reduce CI times and speed up local agent runs.
- Keep configs modular: put short, trivial overrides inside Vite config; keep big configs in separate files to aid other tools and readability.
- Monitor the plugin ecosystem for expanded framework support before fully replacing ESLint/Prettier on large projects.
Notable quotes & quick insights from the episode
- “Go from six config files to one config file.” — the core DX goal.
- VP command is intentionally short: “Short King loves a short command.”
- “Only pre-existing errors.” — task caching and selective re-checking help skip work on unchanged files.
- Hosts’ outlook: enthusiastic to use Vite+ for most new/smaller projects; cautious about immediately replacing everything for large or framework-specific codebases.
Conclusion
Vite Plus is a promising consolidation of modern JS tooling into a single, fast, opinionated developer experience. Its strengths are speed, sensible defaults, a concise CLI, monorepo support and integrated node/version management. For many new projects it looks like a great default; for existing large or framework-specific codebases it’s worth adopting incrementally—start with the VP CLI, task runner and node management, then assess linter/formatter replacement as plugin support matures.