Overlooked Productivity Hack: Format on Save

Formatters like ruff (Python), rustfmt (Rust), gofmt (Go), or Prettier (Javascript) are fairly widespread and well-used. What is not as well-used, however, is the "Format on Save" in code editors.

This option saves me tens of minutes per day, and I would argue that it is mandatory when using a formatter.

What does it do? It automatically runs the formatter when you hit save. It's that simple. But the productivity gain is hard to overemphasize, and the benefit of it hard to appreciate until you start using it yourself.

I had an interview with a live coding exercise using HackerRank, with a web-based editor. While doing some repetetive reformatting for readability, I absent-mindedly remarked that it was a pain. The interviewer retorted that "it's not hard to format code". I replied that I use "Format on Save"; but in retrospect I don't think the interviewer understood what it was. I did not get the job.

Format on Save has a number of benefits:

• You instantly see what the formatter does.
  • It means there are no more surprises if the formatter is doing something undesirable. You immediately get a chance to address the problem, which often saves time compared to fixing it later, as the act of undoing the bad formatting increases the amount of work that must be done.
  • Most formatters have directives to turn them off for specific blocks of code, or other directives to control minor aspects of the formatting. For example, in Python, we have the "Magic Trailing Comma", which gives you some control over how the formatter behaves. Reducing the friction to experiment with these options improves the final product.
  • Without using Format on Save, it's not uncommon to only discover that the formatted code looks silly late in the process of creating a PR. Having to revisit work you've just done is always annoying.
  • Format on Save therefore remedies perhaps the biggest pain point with the use of formatters.
• You never have to manually format your code. This sounds obvious, but if you only run the formatter right before you commit, then you still have to continually hand-format your code when writing it, which defeats the much of the utility of a formatter in the first place. Automatically running the formatter not only saves many keystrokes, but it reduces the chances that CI will reject your code, which in turn eliminates unnecessary back-and-forth when creating a PR. (I realise that Git Hooks exist, but they aren't ergonomic at all).
• You can truly focus on the content of your code. It's hard to describe, but Format on Save results in a mental clarity and a feeling of freedom, as you are unburdened from a task that a computer can easily handle for you. It is easier to enter a hyperproductive flow state, as you are not constantly interrupted by thoughts of "This is unreadable; I need to add a newline there, and spaces here, and a pair of brackets there, and somehow reduce the line length here".
• You can fearlessly refactor things. You can move code around and rename variables/classes/structs/modules with ease, and the code always remains pristine. You never end up in a situation where the line accidentally becomes unreadable (which would require reformatting before you can reasonably continue editing), because the formatter immediately takes care of it. "Update-to-date all of the time" will always beat "up-to-date some of the time".

Format on Save is available in multiple different editors.

Vscode

For example, for Rust, we have:

{
    "[rust]": {
        "editor.defaultFormatter": "rust-lang.rust-analyzer",
        "editor.formatOnSave": true
    },
}

or for Python, we have:

{
    "[python]": {
        "editor.formatOnSave": true,
        "editor.codeActionsOnSave": {
            "source.organizeImports": "explicit"
        },
        "editor.defaultFormatter": "charliermarsh.ruff"
    },
}

Emacs

See the format-all package.

Neovim

See the format-on-save plugin.