Every developer has fought with code formatting at some point. Inconsistent indentation, arguments over tabs versus spaces, pull requests derailed by style debates. It's exhausting, and it's solvable.
A new guide on Dev.to walks through the current landscape of code formatters and linters, and one thing stands out: the tools have gotten fast enough and opinionated enough that there's no excuse for not automating this entirely.
Prettier and ESLint Still Dominate JavaScript
For JavaScript and TypeScript projects, Prettier remains the default choice. It formats your code with minimal configuration, zero arguments, and decent speed. Pair it with ESLint for catching actual errors, and you've got a solid baseline.
The setup is straightforward. Install both, add a config file, hook them into your editor and CI pipeline. Every commit gets formatted automatically. Code reviews focus on logic, not style.
But Prettier has a problem: speed. On large codebases, it's slow. Developers notice the lag. CI jobs take longer than they should. This was acceptable when there was no alternative. Now there is.
Biome Is the Performance Leap
Biome - previously called Rome - is a formatter and linter written in Rust. The pitch is simple: it does what Prettier and ESLint do, but 25 to 35 times faster. That's not incremental improvement. That's a different experience.
The speed comes from being built in Rust and designed from scratch for performance. On a 10,000-file codebase, the difference between 30 seconds and 1 second is the difference between developers waiting and developers not noticing.
Biome also handles both formatting and linting in one tool, which simplifies your setup. Fewer dependencies, faster installs, one config file instead of two. For new projects, it's hard to argue against starting with Biome unless you need specific ESLint plugins that don't have Biome equivalents yet.
Python Has Black and Ruff
Python's formatting story is cleaner than JavaScript's ever was. Black is opinionated, fast, and widely adopted. You install it, it formats your code, and you stop thinking about style.
Ruff is newer and faster - written in Rust, same performance story as Biome. It combines formatting and linting, handles import sorting, and runs fast enough that you can format on every keystroke without lag. For Python projects starting today, Ruff makes sense. For existing projects on Black, the migration is painless enough that it's worth considering.
Go and Rust Have It Built In
Go ships with gofmt. Rust ships with rustfmt. Both are opinionated, both are fast, both are standard. There's no debate about which formatter to use because the language provides one. It's not perfect, but the consistency across every Go or Rust project is worth more than any individual preference.
This is the model other languages should follow. Formatter wars are a waste of time. Standardise on one tool, make it fast, ship it with the language. Done.
CI Integration Is Non-Negotiable
Formatting tools are only useful if they're enforced. That means CI checks that fail if code isn't formatted. Developers should run the formatter locally - ideally on every save - but CI is the backup that catches anything that slips through.
Most CI systems make this trivial. GitHub Actions, GitLab CI, whatever you're using - add a job that runs your formatter in check mode. If it fails, the PR doesn't merge. Simple, effective, no arguments.
The same applies to pre-commit hooks. Install a Git hook that formats code before every commit. Developers never push unformatted code. The CI check becomes a safety net, not the primary enforcement.
Configuration Should Be Minimal
The best formatters are opinionated because configuration is a trap. Every option you expose becomes a debate. Teams waste hours arguing about line length or quote style, when the actual choice barely matters.
Black's philosophy here is right: provide almost no configuration options. If you don't like the style, that's fine - it's consistent, and consistency is more valuable than your preference. Prettier learned this too, though it still offers more knobs than necessary.
For new projects, start with defaults. Only deviate if you have a specific, documented reason. "We've always done it this way" is not a reason. Save the config file complexity for things that actually affect functionality.
The Real Win Is Time
Code formatting is one of those problems that seems small until you add up the hours. Every style debate in a PR, every manual indentation fix, every CI failure because someone forgot to run the formatter - it compounds.
Automating it completely gives you time back. Not just the time spent formatting, but the mental overhead of thinking about it at all. Your editor formats on save, CI enforces it, and you never discuss it again. That's the goal.
If you're not already using a formatter, start with the obvious choice for your language: Prettier for JavaScript, Black or Ruff for Python, gofmt for Go, rustfmt for Rust. If you're on Prettier and feeling the performance pain, look at Biome. The migration is easier than you think, and the speed difference is immediately noticeable.
Code formatting is a solved problem. The only question is whether you're using the solution.