Use Biome Instead of ESLint + Prettier — Why Not?
A plain-English look at why replacing 'two arguing inspectors running on Node.js' (ESLint + Prettier) with a single unified Rust engine (Biome) makes your formatting and linting up to 35× faster.
💡 “It’s not that ESLint and Prettier are bad — they served the web community faithfully for a decade. Biome simply does both jobs in a single breath… up to 35× faster and with zero configuration fights.”
1. The Tale of “Two Book Editors Who Refuse to Share a Brain”
To explain this in plain English for non-specialists: when a team of engineers builds software together, everyone has slightly different typing habits. To keep the codebase clean and bug-free like a professionally edited book, JavaScript and TypeScript teams have traditionally hired two separate inspectors:
- Prettier (The Page Formatter): Only cares about visual neatness — indentation, line wraps, and semicolons.
- ESLint (The Grammar & Logic Inspector): Hunts for actual coding mistakes, unused variables, and bug-prone patterns.
Having both sounds great on paper, until you hit three everyday headaches:
- They Fight Each Other: ESLint yells “Put a space here!”, then Prettier jumps in and says “No, delete that space!”. Developers have to install extra referee packages (
eslint-config-prettier) just to stop them from undoing each other’s work! - Every File Is Read Twice: Because ESLint and Prettier are two completely separate tools written in JavaScript (Node.js), every time you hit Save, Prettier opens your 1,000 files and parses them into a syntax tree; once it finishes, ESLint opens the exact same 1,000 files and parses them all over again from scratch!
- Configuration Sprawl: Before writing a single line of business logic, your project is cluttered with 6+ npm packages and 3–4 separate dot-files (
.eslintrc.json,.prettierrc,.eslintignore).
That is the exact mess Biome was engineered to eliminate.
Compare the Legacy Duo (ESLint + Prettier) against the Unified Biome Rust Engine in the interactive simulator below:
Imagine hiring two separate inspectors to check a 1,000-page manuscript: Inspector A (Prettier) only cares about margins and spacing, while Inspector B (ESLint) checks grammar. Because they don't share the same brain, Inspector A reads all 1,000 pages and rewrites them; then Inspector B has to read all 1,000 pages AGAIN from scratch—and you have to hire a referee (eslint-config-prettier) just to stop them from fighting!
2. What Makes Biome So Ridiculously Fast?
Biome (the spiritual successor to Rome) is an all-in-one web toolchain written from the ground up in Rust — a native systems language famous for bare-metal speed and multi-core parallelism.
Instead of bolting two separate tools together, Biome unifies the Formatter and the Linter inside a single brain:
A. 15× to 35× Faster Execution (Single-Pass Rust Engine)
When processing thousands of files, combining native Rust threads with a Single-Pass Architecture (reading each file once to perform both linting and formatting) yields dramatic benchmarks:
- Formatting code is ~35× faster than Prettier.
- Linting code is ~15× faster than ESLint.
In daily life, that means hitting Ctrl + S in VS Code feels instantaneous, pre-commit hooks finish in the blink of an eye, and CI/CD pipelines shave off minutes of billable compute time on every pull request.
B. From 6 Clashing Packages Down to One biome.json
Look at how much clutter disappears when you switch:
| Before (ESLint + Prettier Combo) | Now (With Biome) |
|---|---|
npm i eslint prettier | npm i -D @biomejs/biome (1 package total!) |
npm i eslint-plugin-react | Built natively into the core |
npm i @typescript-eslint/parser | Built natively into the core |
npm i @typescript-eslint/eslint-plugin | Built natively into the core |
npm i eslint-config-prettier (Conflict referee) | Not needed — Linter & Formatter share one brain! |
.eslintrc.json + .prettierrc + .eslintignore | Single biome.json file |
C. 97% Prettier Compatibility & Crystal-Clear Diagnostics
The Biome team knew nobody wanted a tool that reformats their entire codebase into a weird new style, so they engineered Biome to be ~97% compatible with Prettier’s output. Migrating an existing project produces virtually zero diff noise.
Even better, when Biome flags a lint error, it doesn’t just throw a cryptic rule name at you — it prints a rich diagnostic explaining why the pattern is dangerous and offers a safe one-click autofix.
3. Fair Trade-offs: When Should You Keep ESLint Around?
No tool is a silver bullet for every edge case:
- Niche Plugin Ecosystems: ESLint has a decade-old library of community plugins (custom corporate rules, specialized framework linters). While Biome already offers first-class support for JavaScript, TypeScript, React (JSX/TSX), JSON, and CSS, projects relying heavily on custom Vue/Svelte/Angular template rules may still pair Biome’s blazing formatter with framework-specific checks while Biome expands its HTML/template coverage.
4. Try Biome in Under 3 Minutes
You can test-drive Biome on any project today with three commands:
# 1. Install the single Biome binary package
pnpm add -D -E @biomejs/biome
# 2. Generate a clean biome.json config
npx @biomejs/biome init
# 3. Format, lint, and apply safe fixes in one pass!
npx @biomejs/biome check --write .Install the official Biome extension in VS Code, and enjoy zero-lag saves from day one.
5. Bottom Line: Why Not?
Especially in the AI Coding Agent era — where automated hooks run your linter and formatter dozens of times per minute after every AI edit — waiting 14 seconds for Node.js linters kills your momentum. Dropping that feedback loop down to 0.4 seconds with Biome keeps both you and your AI agents moving at full speed!
Written by Hien Nguyen – Fullstack Dev obsessed with lean, fast toolchains.