Prettier, ESLint, “Shittier”, and Biome

Modern JavaScript Code Quality: From Toolchain Chaos to Unified Performance

Introduction

Formatting and linting are no longer optional in modern JavaScript and TypeScript projects. As codebases grow and teams scale, consistent style, correctness, and performance become critical.

For years, the ecosystem revolved around Prettier + ESLint, sometimes humorously (or painfully) referred to as “Prettier + Shittier” due to configuration complexity, performance issues, and overlapping responsibilities.

Enter Biome — a new-generation tool aiming to replace multiple tools with one fast, unified solution.

This article compares Prettier, ESLint, and Biome, explains where the pain points come from, and helps you decide what to use in 2025.

1. Prettier: Opinionated Code Formatter

What Prettier Does Well

Prettier is a code formatter, not a linter.

• Enforces consistent formatting
• Eliminates style debates
• Supports JS, TS, JSON, Markdown, YAML, HTML, CSS
• Zero-config philosophy

npx prettier --write .

Strengths

✅ Deterministic output ✅ Easy to adopt ✅ Huge ecosystem support

Limitations

❌ No code-quality rules ❌ No semantic understanding ❌ Requires ESLint alongside it

Prettier answers “How should the code look?”, not “Is the code correct?”

2. ESLint: Powerful but Fragmented Linting

What ESLint Does

ESLint analyzes code semantically to detect:

• Bugs
• Anti-patterns
• Unsafe logic
• Best-practice violations

npx eslint .

Strengths

✅ Extremely flexible ✅ Massive plugin ecosystem ✅ Deep AST-based analysis

The Problems

❌ Slow on large projects ❌ Complex configuration ❌ Rule conflicts with Prettier ❌ Plugin maintenance burden

A typical ESLint setup today includes:

• eslint
• @typescript-eslint
• eslint-config-prettier
• eslint-plugin-import
• eslint-plugin-react
• custom overrides

This is where the nickname “Shittier” comes from — not because ESLint is bad, but because the combined DX often is.

3. “Prettier + ESLint” (a.k.a. “Shittier”)

Why Developers Complain

Common frustrations:

• Formatting rules disabled just to avoid conflicts
• Slow CI checks
• Inconsistent results between editor and CI
• Endless config tuning

{
  "extends": ["eslint:recommended", "prettier"]
}

Even with best practices, teams still ask:

“Why do I need 5 tools to do one job?”

4. Biome: The Unified, Fast Alternative

What Is Biome?

Biome (formerly Rome) is an all-in-one tool written in Rust that provides:

• Formatter (Prettier replacement)
• Linter (ESLint replacement)
• Import sorting
• Code actions
• TypeScript support

npx biome check .
npx biome format .

Core Design Philosophy

• One config file
• One binary
• High performance
• Zero plugin chaos

Strengths

✅ Extremely fast (Rust-based) ✅ Unified formatting + linting ✅ Minimal configuration ✅ Consistent editor & CI behavior

Limitations (as of now)

❌ Smaller rule ecosystem than ESLint ❌ Less framework-specific rules ❌ Rapidly evolving (breaking changes possible)

5. Feature Comparison

| Feature           | Prettier | ESLint    | Biome         |
| ----------------- | -------- | --------- | ------------- |
| Formatting        | ✅        | ❌         | ✅             |
| Linting           | ❌        | ✅         | ✅             |
| Performance       | ⚡ Fast   | 🐢 Slow   | 🚀 Very Fast  |
| Config Complexity | Low      | High      | Very Low      |
| Plugins           | ❌        | ✅ Huge    | ❌ (by design) |
| TypeScript        | Partial  | Excellent | Native        |
| One-tool Solution | ❌        | ❌         | ✅             |

6. When Should You Use What?

Use Prettier + ESLint if:

• You need niche lint rules
• You rely on framework-specific plugins
• You maintain legacy projects

Use Biome if:

• You’re starting a new project
• You want fast CI
• You prefer simplicity over endless customization
• You’re tired of config wars

Many teams now use Biome + TypeScript compiler checks and drop ESLint entirely.

7. A Practical Recommendation (2025)

For new projects:

npx biome init

For existing projects:

• Keep ESLint where needed
• Gradually introduce Biome for formatting
• Remove Prettier first
• Measure CI speed improvements

Conclusion

Prettier and ESLint shaped modern JavaScript development, but their combination has reached a complexity ceiling.

Biome represents a new direction:

• Fewer tools
• Faster execution
• Better developer experience

The future of frontend tooling is not more plugins — it’s fewer, faster, smarter tools.