Developer Automation Tools: Automate the Boring Work

The developer automation tools worth setting up first are a formatter and linter (Prettier, ESLint, Ruff), pre-commit hooks (pre-commit or Husky with lint-staged), CI that runs tests on every pull request (GitHub Actions or GitLab CI), automated dependency updates (Dependabot or Renovate), and a task runner (npm scripts, make or just). Together they remove most of the repetitive work in a codebase: style debates, "did you run the tests?", stale dependencies and hand-written release notes.

Below is what to automate, in the order that pays off fastest, with working configs you can copy. Versions are current as of October 2026.

What to automate, and with what

Chore	Tool	Where it runs
Code formatting	Prettier (JS/TS/CSS), Ruff or Black (Python), gofmt, rustfmt	Editor on save, pre-commit, CI
Linting	ESLint, Ruff, golangci-lint, Clippy	Pre-commit, CI
Checks before commit	pre-commit, Husky + lint-staged	Developer machine
Tests on every PR	GitHub Actions, GitLab CI	CI
Dependency updates	Dependabot, Renovate	Opens PRs on a schedule
Releases and changelogs	release-please, semantic-release, Changesets	CI on main
Dev environment setup	Dev Containers, Nix, mise	Developer machine or Codespaces
Repeated commands	npm scripts, make, just, Task	Anywhere

Start at the top. Formatting and CI give the biggest return for the least setup.

1. Format and lint automatically

Turn on format-on-save in your editor and commit the config to the repo, so everyone gets the same result. In VS Code, add .vscode/settings.json:

{
  "editor.formatOnSave": true,
  "editor.codeActionsOnSave": { "source.fixAll.eslint": "explicit" }
}

Then make CI fail if code isn't formatted (npx prettier --check . or ruff format --check). Once the tool decides the style, code review stops being about commas.

2. Run checks before every commit

Pre-commit hooks catch problems before they reach CI, which saves a full CI round trip for a missing semicolon.

JavaScript and TypeScript: Husky and lint-staged

Husky installs Git hooks; lint-staged runs tools only on the files you staged, so hooks stay fast.

npm install --save-dev husky lint-staged
npx husky init
echo "npx lint-staged" > .husky/pre-commit

Add the rules to package.json:

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

Any language: pre-commit

The pre-commit framework manages hooks for any language from one YAML file. This config trims whitespace, blocks large files and accidental private keys, and lints and formats Python with Ruff:

# .pre-commit-config.yaml
repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v6.0.0
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-added-large-files
      - id: detect-private-key
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.17.0
    hooks:
      - id: ruff-check
        args: [--fix]
      - id: ruff-format

Install it with pip install pre-commit && pre-commit install, and run pre-commit autoupdate now and then to bump the rev pins.

Hooks can be skipped with git commit --no-verify, so always run the same checks in CI too.

3. Test every pull request in CI

GitHub Actions is free for public repositories, and private repositories get a monthly allowance of minutes that depends on your plan (billing docs). A minimal Node.js workflow:

# .github/workflows/ci.yml
name: CI
on:
  push:
    branches: [main]
  pull_request:

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
      - uses: actions/setup-node@v7
        with:
          node-version: 24
          cache: npm
      - run: npm ci
      - run: npm run lint
      - run: npm test

Then protect main in the repo settings so pull requests can't merge until this job passes. That one setting turns "please run the tests" into a rule nobody has to enforce. If you're deciding between hosted CI services, see GitHub Actions vs GitLab CI or free GitHub Actions alternatives.

4. Let a bot update your dependencies

Updating dependencies by hand is the chore teams skip until a security advisory forces a painful jump. Dependabot is built into GitHub; this config opens one grouped PR a week for minor and patch updates, and keeps your Actions versions current:

# .github/dependabot.yml
version: 2
updates:
  - package-ecosystem: npm
    directory: /
    schedule:
      interval: weekly
    groups:
      minor-and-patch:
        update-types: [minor, patch]
  - package-ecosystem: github-actions
    directory: /
    schedule:
      interval: weekly

Renovate does the same job with more control (automerge rules, monorepo grouping, many more package managers) and works on GitLab and Bitbucket too. With CI from step 3 in place, you can safely automerge patch updates that pass.

5. Automate releases and changelogs

If you follow Conventional Commits (feat:, fix:), a tool can work out the next version number and write the changelog. release-please keeps a release PR open and updates it as you merge; merging it tags the release:

# .github/workflows/release.yml
name: release-please
on:
  push:
    branches: [main]
permissions:
  contents: write
  pull-requests: write
jobs:
  release-please:
    runs-on: ubuntu-latest
    steps:
      - uses: googleapis/release-please-action@v5
        with:
          release-type: node

semantic-release publishes fully automatically on every merge; Changesets suits monorepos where contributors describe changes in small files.

6. Make setup a single command

"It works on my machine" is a setup problem. A Dev Container describes the environment in the repo, and VS Code, JetBrains IDEs and GitHub Codespaces can build it:

// .devcontainer/devcontainer.json
{
  "image": "mcr.microsoft.com/devcontainers/base:ubuntu",
  "features": {
    "ghcr.io/devcontainers/features/node:1": { "version": "lts" }
  },
  "postCreateCommand": "npm ci"
}

Then give repeated commands short names. A justfile (just) or Makefile documents how the project runs:

# justfile
dev:
    npm run dev

check:
    npm run lint && npm test

db-reset:
    docker compose down -v && docker compose up -d db && npm run migrate

New contributors run just --list and see everything the project can do.

7. Hand the leftovers to AI agents, with review

AI coding agents (GitHub Copilot's coding agent, Claude Code, Cursor and others) are now good at the chores that don't fit a config file: writing missing tests, migrating deprecated APIs, fixing lint errors across a codebase, drafting PR descriptions. Treat their output like a junior teammate's pull request: it goes through the same CI and the same review. Our vibe coding guide and Cursor vs GitHub Copilot cover the trade-offs.

Mistakes to avoid

• Slow hooks. If a pre-commit hook takes more than a few seconds, people will bypass it. Run full test suites in CI, not in hooks.
• Automation nobody owns. A Dependabot PR queue that nobody merges is worse than none. Group updates and automerge the safe ones.
• Unpinned CI actions. Pin actions to a major version at least (@v7); security-sensitive repos pin to a full commit SHA.
• Secrets in workflows. Use your CI's secret store and the minimum permissions each job needs.

For more tools, browse DevOps tools on DevHunt.

FAQ

What is developer automation?

Using tools to run the repetitive parts of software work for you: formatting, linting, testing, dependency updates, builds, releases and environment setup. The goal is that the correct thing happens by default, without anyone remembering to do it.

What should a small team automate first?

Formatting on save and a CI workflow that runs tests on every pull request, with branch protection on main. Add Dependabot or Renovate next.

Husky or pre-commit?

Husky with lint-staged is the common choice in JavaScript projects because it installs through npm. pre-commit is language-agnostic and better for Python or mixed-language repos. Both just run Git hooks.

Dependabot or Renovate?

Dependabot is built into GitHub and needs only a YAML file. Renovate is more configurable, supports more package managers and also runs on GitLab and Bitbucket.

Are these automation tools free?

The tools in this guide are free and open source, or free for public repositories. GitHub Actions minutes for private repositories are limited by plan, so check your usage if you run long builds.