My Opinionated VS Code Setup — Fast, Quiet, and Intentional

If you’ve been using VS Code for a while, you eventually stop chasing shiny extensions and start shaping the editor around how your brain works. This is my current setup: opinionated, minimal where it matters, and optimized for flow, clarity, and clean diffs. I’ll walk through the key settings, why I chose them, and a few optional twists you can adopt.

Philosophy

Three guiding principles:

1. Reduce cognitive noise (visual clutter, surprise popups, irrelevant hints).


2. Automate the boring stuff (format, whitespace hygiene, commit friction).


3. Make intentional actions fast (force pushing, smart commit paths, navigation).

Editor Experience

editor.formatOnSave: true

I trust my formatter. Every save is a cleanup checkpoint; it prevents stylistic bikeshedding and keeps diffs small. If a tool misbehaves, I’ll toggle it per-language rather than globally.

editor.guides.bracketPairs: "active" & editor.guides.bracketPairsHorizontal: "active"

I write nested code (JS, config files, sometimes JSON). Active guides help my eyes snap to structure without turning the editor into a picket fence of lines. Horizontal guides are underrated—they clarify multi-line constructs like chained functions or deeply nested objects.

Disabled extras: editor.minimap.enabled: false, editor.stickyScroll.enabled: false

The minimap is just a guilt meter showing how big the file got. Sticky scroll is neat, but I prefer jump-to-symbol and breadcrumbs instead of pinning headers visually. Less motion, more intent.

editor.wordWrap: "on"

I read a lot of Markdown and comments. Hard horizontal scrolling kills flow. Wrap it, but keep line-length discipline in code via formatter rules.

Pro tip: If you collaborate with folks who hate wrap, consider enabling wrap only for markdown, plaintext, and json via language-specific settings.

Extension & Recommendation Hygiene

extensions.ignoreRecommendations: true

I don’t want a slot machine of extension suggestions mid-session. My environment evolves deliberately, not reactively.

github.copilot.nextEditSuggestions.enabled: false

I like AI assistance, but I disable speculative hover “next edits” to avoid nudges when I’m still thinking. Pull help on demand; don’t let it push.

File Discipline

files.autoSave: "onFocusChange"

This is the “save when you context-switch” mode. Prevents forgotten unsaved buffers, but doesn’t interrupt rapid iterative edits like afterDelay can.

Whitespace hygiene trio:

files.insertFinalNewline: true

files.trimFinalNewlines: true

files.trimTrailingWhitespace: true

These keep diffs trustworthy. No more accidental noise at EOF or stray spaces triggering CI lint jobs. Silent janitor.

Optional tweak: If you work with Makefiles or languages where trailing spaces matter, scope trimTrailingWhitespace exclusions via .editorconfig.

Git & GitHub Workflow

git.allowForcePush: true

Force pushing is a power tool. I rebase and refine history regularly on feature branches (never on shared stable). This setting removes the extra friction but demands discipline.

git.enableSmartCommit: true

Stage-less commits with a single shortcut when everything is intentional. Pair this with habits: run tests, glance at diff, save all, commit.

git.blame.statusBarItem.enabled: true

Inline blame can be overwhelming; I prefer ephemeral, opt-in context. Status bar blame lets me hover when curious instead of reading a cemetery of gray annotations.

git.confirmSync: false

If I hit Sync, I meant it. Reducing yes/no dialog fatigue.

Consider enabling git.autofetch if you haven't; pairs well with quick sync.

Window & Workbench

workbench.startupEditor: "none"

Startup silence. No welcome screen, just the code I came for. My muscle memory opens recent projects via the command palette anyway.

window.openFilesInNewWindow: "on" & window.openFoldersInNewWindow: "on"

Keeps context separation sharp. A new folder is a new mental sandbox—not muddled into an existing session.

workbench.tree.indent: 20

Slightly larger indent improves scan-ability of deeply nested folder structures. Treat the file explorer like a well-typeset outline.

Chat / AI

chat.agent.enabled: true

I want AI available—but as a tool, not an interruption. This complements my other disabled speculative features; assistance remains intentional.

Commented-Out Choices (Intentional Restraint)

Some settings are commented out (font sizes, tab size, suggest folders, terminal font). That’s deliberate: they’re toggles I may re-enable for pairing, presenting, or deep refactor sessions. Comments act as a lightweight personal preset ledger.

Example reversible tweak block:

// Presentation mode:

// "editor.fontSize": 16,

// "terminal.integrated.fontSize": 14,

// "editor.minimap.enabled": true

Keep these in comments—fast context switching without hunting docs.

Micro-Optimizations You Could Add

If you resonate with this setup, consider layering:

-- Diagnostics calm mode: editor.inlineSuggest.enabled: false if AI inline ghosts distract you.

• Explorer clarity: "explorer.compactFolders": false for explicit folder depth.


• Safer force-push culture: combine local freedom with remote branch protection.


• Intent logging: enable "files.hotExit": "onExitAndWindowClose" if you often juggle unsaved scratch buffers.

A Minimal .editorconfig Companion

Pair whitespace rules in both VS Code and collaborators’ editors:

root = true



[*]

end_of_line = lf

insert_final_newline = true

trim_trailing_whitespace = true

charset = utf-8



[*.md]

trim_trailing_whitespace = false

Stops Markdown lists from losing intentional double-space line breaks.

Why This Matters

Your editor is a thinking surface. Every popup dismissed, every accidental diff artifact cleaned manually, every needless glare of a minimap is attrition—tiny energy leaks. Settings like these patch the leaks so creative and critical work gets the wattage instead.

Copy/Paste Starter Block

If you want a fast jump-off, adapt:

{

    "editor.formatOnSave": true,

    "editor.guides.bracketPairs": "active",

    "editor.guides.bracketPairsHorizontal": "active",

    "editor.minimap.enabled": false,

    "editor.stickyScroll.enabled": false,

    "editor.wordWrap": "on",

    "extensions.ignoreRecommendations": true,

    "files.autoSave": "onFocusChange",

    "files.insertFinalNewline": true,

    "files.trimFinalNewlines": true,

    "files.trimTrailingWhitespace": true,

    "git.allowForcePush": true,

    "git.blame.statusBarItem.enabled": true,

    "git.enableSmartCommit": true,

    "github.copilot.nextEditSuggestions.enabled": false,

    "window.newWindowProfile": "Default",

    "window.openFilesInNewWindow": "on",

    "window.openFoldersInNewWindow": "on",

    "workbench.startupEditor": "none",

    "workbench.tree.indent": 20,

    "chat.agent.enabled": true,

    "git.confirmSync": false

}

Closing

This setup won’t fit everyone, and that’s the point—settings are a userland dialect for how you approach code. Treat them as evolving artifacts of your workflow maturity. Borrow what resonates, ignore what doesn’t, and annotate your choices so future-you remembers the why.

Got a contrarian setting you swear by? Drop it in the comments—love comparing mental models.