The JavaScript toolchain grows every year, and the hard part is not finding tools — it is choosing the right one for a job. This guide compares the essential JavaScript developer tools by category, states what each is best at, and links to the ones I maintain at BenihKode.
The categories that matter
Any serious JS project needs coverage in five areas:
- Lint the code for mistakes and inconsistency.
- Format the code so nobody argues about style.
- Bundle/build it for the browser or Node.
- Test behavior automatically.
- Automate the everyday CLI chores around the repository.
Pick one tool per category, wire them into scripts, and stop thinking about tooling.
Linters: ESLint vs. Biome
| Tool | Strengths | Trade-off |
|---|---|---|
| ESLint | Enormous plugin ecosystem, framework rules (React, Vue), battle-tested | Slower; config sprawl as plugins accumulate |
| Biome | Fast (Rust), lint + format in one binary, near-zero config | Smaller rule set than ESLint’s plugin ecosystem |
Choose ESLint when your framework needs specific rules or your team already has a config. Choose Biome for new projects that want speed and one tool instead of two.
Formatters: Prettier vs. Biome
Prettier remains the default: opinionated, editor-integrated, and supported everywhere. Biome’s formatter is a fast, compatible alternative that removes the ESLint+Prettier pairing in favor of one binary. Either is fine — the important decision is to automate formatting and never discuss it in review again.
Build tools: Vite, esbuild, and webpack
| Tool | Best for | Notes |
|---|---|---|
| Vite | App development with dev server | Fast HMR; uses esbuild and Rollup under the hood |
| esbuild | Raw speed, small builds | Go-based, extremely fast, minimal plugins |
| webpack | Complex legacy setups | Deep plugin ecosystem; heavier configuration |
For most new apps, start with Vite. Reach for esbuild when you need a fast low-level transform, and keep webpack only where its plugin ecosystem is doing irreplaceable work.
Test runners: Vitest vs. Jest
Jest is the long-standing standard with a mature ecosystem. Vitest is API-compatible for most tests and integrates natively with Vite, with faster startup. New Vite projects should default to Vitest; existing Jest suites are usually not worth migrating without a reason.
CLI utilities that fill the gaps
Build tooling is the visible half of the toolchain. The other half is the small, repeated chores — and these are the tools that disappeared into my workflow:
- gitcommitgen — generate conventional commit messages
from the staged diff:
gitcommitgen --commit. - secretsweep — scan staged files for keys before you
push:
npx secretsweep staged. - jsonask — query JSON without writing
jq:jsonask data.json "count by status". - envtainer — validate
.envfiles before the app starts:envtainer validate. - gitprgen — draft the pull request description from the same diff.
A curated list of these and more is in Open Source CLI Tools on npm.
How to choose without over-researching
Three rules keep tool selection cheap:
- Default to the popular, maintained option. It has answers when you get stuck.
- Prefer fewer tools. One tool that lints and formats beats two that overlap.
- Automate via npm scripts. The tool choice is only real once it runs on
pnpm testor on commit.
{
"scripts": {
"lint": "eslint .",
"format": "prettier --write .",
"test": "vitest run",
"validate:env": "envtainer validate"
}
}Once these scripts exist, the toolchain is a single pnpm lint && pnpm test
away — which is the point.
Package managers: npm, pnpm, and yarn
The toolchain sits on a package manager, and the choice affects install speed and disk use.
| Manager | Strengths | Trade-off |
|---|---|---|
| npm | Ships with Node, universal support | Slower installs, larger node_modules |
| pnpm | Fast, content-addressed store, strict hoisting | Occasional incompatibility with packages assuming flat node_modules |
| yarn | Fast, mature workspaces | Two major modes (classic vs. berry) can confuse docs |
For new projects, pnpm is a good default: it is fast and its strict dependency resolution surfaces accidental imports early. Use npm when a project must run on a locked-down environment where only the bundled client is available, and yarn when a monorepo already standardizes on it.
Wiring it into CI
Tool choices only pay off once they run automatically. A minimal CI job for a JavaScript project runs the same scripts you run locally:
- run: pnpm install --frozen-lockfile
- run: pnpm lint
- run: pnpm test
- run: pnpm buildTwo details matter: install with a frozen lockfile so CI cannot silently upgrade dependencies, and make the local and CI commands identical. When the commands differ, “works on my machine” becomes a recurring ticket rather than a one-off bug.
A minimal recommended stack for 2026
- Lint + format: Biome, or ESLint + Prettier if you need plugins.
- Build: Vite (with esbuild as its transformer).
- Test: Vitest.
- CLI chores: gitcommitgen, secretsweep, jsonask, and envtainer.
That set is small, fast, and covers lint, format, build, test, and the daily chores. The rest of the BenihKode developer tools collection fills specific gaps as they appear, and the Journal documents why each one exists.