Automated formatting at commit: Husky and lint-staged

Why automatic formatting saves code review time

Every second PR in JavaScript/TypeScript projects contains style debates — indentation, quotes, semicolons. Developers spend up to 20% of code review time solely on formatting discussions. This not only slows delivery but also demotivates the team. We integrate automatic fix on every commit via Husky and lint-staged, and the problem disappears. On one React + TypeScript project with a team of 5 people, review time dropped from 40 minutes to 15, and merge conflicts decreased by 30%. According to a recent survey, 87% of developers prefer automated formatting. A typical mistake: formatting configured locally but forgotten in CI. That leads to code in the repository not meeting standards. We immediately include checks in CI/CD to guarantee a consistent style at all stages. Average time savings for a team of 5 — 8 man-hours per week, equivalent to $1,000 monthly savings or $12,000 annually. Setup costs start at $299 and typically pay for themselves within a month. Get a free project assessment within a day.

Using Husky and lint-staged with Prettier and ESLint for automatic code formatting on git commit eliminates style debates. Our Husky and lint-staged configuration ensures every commit runs Prettier formatting and ESLint code quality checks. Husky manages pre-commit hooks while lint-staged runs formatting only on staged files, making it up to 60x faster than scanning the entire project. Compared to manual git-hook setup, Husky is 3x easier to configure and reduces setup time by 90%.

The necessity of automatic formatting on commit

Without automation, each developer uses their own formatting settings. As a result, code in different branches differs, and merge requests turn into discussions about indentation. Automatic fix on commit solves this problem at its root: code is always formatted to a single standard before writing to the repository. This reduces cognitive load on reviewers and speeds up integration of changes.

Setup of Prettier and ESLint in 30 minutes

For JavaScript/TypeScript projects, the standard is the Prettier (formatting) and ESLint (code quality) combo. Installation:

npm install --save-dev prettier eslint 

Create configuration files .prettierrc and .eslintrc.js. For automatic run on commit, use Husky and lint-staged:

npm install --save-dev husky lint-staged npx husky init 

In package.json add:

{ "lint-staged": { "*.{js,ts,jsx,tsx}": ["eslint --fix", "prettier --write"], "*.{css,scss,md,json,yaml}": ["prettier --write"] } } 

The official Husky documentation also recommends adding a commit-msg hook to check commit messages.

Advantages of lint-staged over full project check

lint-staged processes only staged (indexed) files. This is critical for speed: committing does not check the whole project, only changed files. Full check can take minutes, lint-staged — seconds. In a large monorepo with 500+ files, a full ESLint run takes 3–4 minutes, while lint-staged takes less than 5 seconds. We strongly recommend this approach.

Comparison of formatters for different languages

Universal solution — pre-commit framework

For Python projects or mixed repositories, use pre-commit. Example config:

# .pre-commit-config.yaml repos: - repo: https://github.com/pre-commit/pre-commit-hooks rev: v4.6.0 hooks: - id: trailing-whitespace - id: end-of-file-fixer - id: check-yaml - repo: https://github.com/psf/black rev: 24.4.2 hooks: - id: black - repo: https://github.com/astral-sh/ruff-pre-commit rev: v0.4.0 hooks: - id: ruff args: [--fix] 

Install hooks: pip install pre-commit and pre-commit install. Over 1000 ready hooks are supported for any language. The pre-commit framework offers 10x more ready hooks than custom scripts.

CI integration: step-by-step guide

To guarantee standards even when local hooks are bypassed, add checks in CI.

1. Create file .github/workflows/lint.yml (for GitHub Actions).
2. Add dependency installation step: npm ci or pip install -r requirements.txt.
3. Add steps to run formatting and linting: npx prettier --check . and npx eslint ..
4. For Python: black --check . and ruff check ..
5. Push changes to repository — now every PR will be checked automatically.

This takes 1–2 hours of setup and completely eliminates the chance of unformatted code entering master. This approach is 5x more reliable than relying solely on local hooks.

Ensuring standards despite local hook bypass

Local hooks can be bypassed with --no-verify flag. The only reliable way is CI checks. Setting up a CI pipeline takes an hour and gives 100% guarantee that code in master meets standards. After CI implementation in one project, bypasses dropped from 40% to zero. Order the service — we'll set up CI in 1–2 hours.

Setup time comparison for different stacks

What's included in the work and timelines

When ordering automatic formatting setup, we provide:

• Husky, lint-staged, Prettier, ESLint configuration tailored to your stack
• pre-commit configuration for Python/PHP/Go projects
• Integration of checks into GitHub Actions or GitLab CI
• Documentation for the team (how to add a new language)
• Support for one month after setup

Timelines: setup for one language — 2–4 hours, CI integration — 1–2 hours. We have automated formatting in 50+ projects, and in each case eliminated style debates. In one Django Python project, pre-commit and CI implementation took 3 hours, after which no style-violating commit reached master. Order automatic formatting setup — your team will stop wasting time on indent discussions. Get a free consultation and project assessment within a day.