Formatting, linting and why both exist
A formatter rewrites how code looks — indentation, line breaks, quote style, spacing — without altering what it does. A linter analyses what code means and flags problems: unused variables, unreachable branches, suspicious comparisons, likely bugs. They are complementary, and conflating them causes arguments about the wrong things.
The strongest argument for an opinionated formatter is that it ends style debate entirely. When formatting is applied automatically on save, nobody discusses brace placement in review, and every diff contains only semantic changes. That last point compounds: a diff mixing a real change with reformatting is far harder to review, which is why applying a formatter to an existing codebase is best done as a single isolated commit.
Configurability is a genuine trade-off rather than an obvious good. More options mean more per-project decisions and more scope for disagreement; the tools that took off did so partly by refusing to offer many.
Where reformatting can change behaviour
Formatting is meant to be semantically neutral, and in JavaScript there is one notable way it is not. Automatic semicolon insertion means the parser adds semicolons at line breaks under specific rules, so where a line break falls can change meaning. A return followed by a newline and then a value returns undefined, because a semicolon is inserted immediately after return.
Lines beginning with ( or [ are the other hazard: without a terminating semicolon on the previous line, they are parsed as a continuation — a function call or an index — rather than a new statement. This is why formatters that omit semicolons insert a leading one on such lines.
Template literals, regular expressions and multi-line strings must also be left untouched, since whitespace inside them is data. A formatter that reindents the contents of a template literal changes the program's output. Python is the clearest case of formatting being semantic outright, since indentation defines block structure, so a Python formatter can only adjust it within what the grammar permits.
Tabs, spaces and line length
The tabs-versus-spaces argument has one substantive point beneath the tribalism: tabs are configurable by the reader. A developer using a screen reader or a large font can set tab width to whatever suits them, which spaces do not allow. That is a real accessibility argument for tabs, and it is the one most often overlooked in favour of aesthetics.
The counter-argument is alignment. Code aligned with tabs only lines up at one tab width, so mixing tabs for indentation with spaces for alignment is the pragmatic compromise most style guides land on.
Line length limits descend from 80-column terminals, and while monitors are wider, the limit remains useful for a different reason: side-by-side diffs, split editor panes and code review interfaces all show narrow columns, and long lines wrap or require horizontal scrolling in exactly the contexts where code is read most carefully. Somewhere between 80 and 120 characters is the range most projects settle on.