Eight Developer Tool Settings to Change Before Your Next Commit

Archi4 min read

developergitsecurityci

Contents
  1. Eight Developer Tool Settings to Change Before Your Next Commit
  2. 1. Turn on automatic secret scanning in your editor
  3. 2. Pin your formatter and linter versions
  4. 3. Set an explicit branch protection rule
  5. 4. Cap your AI assistant's context window
  6. 5. Fix your Git identity and signing
  7. 6. Make CI fail on warnings you actually intend to fix
  8. 7. Set a time limit on every CI job
  9. 8. Audit which editor extensions can read your files
  10. The order to do it in

Eight Developer Tool Settings to Change Before Your Next Commit#

Most developers inherit their tool configuration the way they inherit a desk: nobody chose it, it was just there on day one. The defaults in an editor, a Git client, or a CI pipeline are tuned for the vendor's demo, not for your repository or your team's bill. Changing a handful of settings takes under an hour and pays back every week after.

This checklist is for people who write code, not for platform teams running the build farm. Each item is something you can change yourself today, and each one has a concrete reason attached.

1. Turn on automatic secret scanning in your editor#

A 2024 sweep of public repositories by security researchers found credentials in roughly one in every thousand commits. Your editor can catch most of them before they leave your machine. GitHub's push protection and GitLab's secret detection both block a commit containing a recognized key format. For local work, install a pre-commit hook from a library like detect-secrets or gitleaks.

The reason to do it today: once a key is pushed, rotating it is a multi-team incident. Blocking it locally takes ten minutes.

2. Pin your formatter and linter versions#

If your team runs Prettier, ESLint, or Ruff without a lockfile, two machines can produce different output from the same source. That shows up as noisy diffs, failed CI runs, and arguments in code review about whitespace.

Add the tool to your package manager's lockfile or a pinned requirements file. Run the formatter through a single command everyone shares, not through an editor plugin that each person configures separately. Editors drift; a checked-in config file does not.

3. Set an explicit branch protection rule#

Repository defaults usually allow force pushes and direct commits to the main branch. On small teams this feels convenient until someone rewrites history on a shared branch and the next three people to pull end up with a mess to untangle.

Turn on two rules: require a pull request before merging, and block force pushes to the default branch. You can keep the rules loose (no required reviewers) if the team is small. The point is to make destructive operations deliberate rather than accidental.

4. Cap your AI assistant's context window#

Coding assistants bill by tokens, and the default behavior is to send a lot of context. A typical editor plugin may attach the open file, the surrounding project structure, and recent edits to every request. Over a month of heavy use, that adds up.

Check the settings panel for a maximum context size and set it to what you actually need. For most autocomplete work, a few thousand tokens is plenty. Also check whether the plugin indexes your whole repository; if it does, confirm what it uploads and whether that includes files you would rather keep local.

5. Fix your Git identity and signing#

Run git config --list and check the name and email on your commits. A surprising number of developers are still committing under a default like "user@localhost" or an old work address, which means contributions never show up on their profile and reviewers cannot tell who wrote what.

Set user.name and user.email explicitly, per repository if you contribute to open source on the side. If your organization requires signed commits, configure a signing key now rather than during an audit. The setup is a one-time cost, and an unsigned commit in a protected branch will block a merge.

6. Make CI fail on warnings you actually intend to fix#

A pipeline that prints 400 warnings and exits green trains everyone to ignore the log. Pick two or three warning categories that matter (deprecated APIs, unused imports, type errors in changed files) and make those fail the build. Leave the rest as warnings.

The trick is scoping: enforce on changed code, not the whole repository, or you will spend a week clearing a backlog nobody wants to touch. Most CI systems support a diff-based mode through a plugin or a third-party service.

7. Set a time limit on every CI job#

Default job timeouts are often generous, sometimes nonexistent. A hung test or a network call that never returns can hold a runner open for an hour. On metered runners, that is money; on self-hosted ones, it is a queue that blocks everyone else.

Set a timeout per job based on the observed 95th percentile, plus a margin. If a normal build takes four minutes, a 15-minute cap is reasonable. The cap also surfaces genuinely slow tests that crept in over months.

8. Audit which editor extensions can read your files#

Every extension you install runs with the same access as the editor itself. That includes reading any file in the open workspace and, in some cases, making network requests. Open the extension list, sort by install date, and remove anything you have not used in a month.

For the ones you keep, check whether they are still maintained and when they last shipped an update. An extension untouched for three years is a small liability that costs nothing to drop.

The order to do it in#

Start with the pre-commit hook and the branch protection rule, because those two prevent the problems that take the longest to undo. Then pin your tooling and fix your Git identity, which are quick and stop recurring noise. The CI and extension changes can follow over the next week.

None of these settings requires a budget approval or a platform team ticket. They are the kind of defaults that stay wrong for years simply because nobody looked.

More articles