Inside My VS Code Setup: Theme, Extensions, and Settings

If you spend hours a day in your editor, your setup stops being a cosmetic preference and starts becoming part of how you think. Mine has evolved into a very opinionated VS Code environment tuned for the work I do most often: Go, Python, PowerShell, Ansible, Terraform, Markdown, YAML, JSON, and a steady stream of GitHub-driven automation.

Earlier this month, I wrote about why I use JetBrains GoLand and PyCharm over VS Code for some language-specific work. That's still true. But VS Code remains one of the most useful tools on my machine because it is fast, flexible, and easy to shape around the task in front of me.

This post is a tour of the setup I keep coming back to, the one that feels like home every time I open VS Code.

My Stack, and Why It Shapes the Editor¶

The first thing worth saying is that editor setup is never one-size-fits-all. Mine reflects the languages and tools I touch constantly:

• Go for systems work, CLIs, and open source tooling, especially Terraform providers and Packer plugins
• Python for scripting, automation, and utility work, especially when I need to build Ansible modules or other small tools quickly
• PowerShell for platform automation and the kind of administrative tasks that still show up constantly in real environments
• Ansible for playbooks, inventories, and repeatable automation across systems
• Terraform and HCL for infrastructure-as-code
• Markdown, YAML, JSON, and shell scripts for documentation, configuration, and all the glue between bigger pieces

That mix pushes me toward a setup that values readability, fast formatting, strong Git integration, and language tooling that feels dependable instead of clever.

Theme, Font, and General Vibes¶

I use the Dracula theme, FiraCode, and font ligatures enabled.

That combination hits a sweet spot for me. Dracula has enough contrast to stay readable during long sessions without becoming visually harsh, and FiraCode makes dense code feel a little cleaner, especially in languages with lots of operators and punctuation. I also use FiraCode across more than just the editor itself, including the terminal, diff views, blame overlays, chat panes, and the SCM input box. That consistency matters more than people think. When every surface looks and feels related, the whole editor becomes easier to scan.

For icons, I use Material Icon Theme, specifically the React/Redux icon pack. Good file icons are a tiny thing until you lose them. Then suddenly every sidebar looks flatter and slower. I don't need them to be flashy, but I do want the Explorer to be easy to parse at a glance.

I also keep the visual clutter down aggressively:

• The minimap is disabled because I never get meaningful signal from it
• A ruler at column 120 keeps me honest in prose and code
• I use a thin cursor with smooth caret animation because it feels precise without being distracting
• Preview tabs are disabled, because I want files to stay open until I decide otherwise

In short, I want VS Code to feel sharp, calm, and legible.

Must-Have Extensions¶

I have plenty of extensions installed, but these are the ones that genuinely earn their keep.

Productivity and Workflow¶

• GitLens: adds deep Git context directly into the editor, and I especially love the inline blame, history, and quick navigation when I am figuring out why a line changed.
• GitHub Copilot: helps with repetitive scaffolding and first-pass suggestions, but the real win is keeping momentum when I already know where I want the code to go.
• GitHub Copilot Chat: gives me an in-editor assistant for brainstorming, refactoring, and quick explanations without leaving the repository context.
• GitHub Pull Requests and Issues: lets me review, check out, and manage pull requests without bouncing back and forth between browser tabs all day.
• GitHub Actions: makes workflow files easier to work with and gives me better visibility into CI from inside the editor.
• Git Graph: provides a visual view of branch history that's much easier to reason about than a wall of raw commit hashes.
• Prettier: remains my default formatter for the broad "miscellaneous text and config file" category where I just want things cleaned up automatically.
• Todo Tree: surfaces scattered TODOs and FIXMEs across a repository, which is helpful when I am revisiting older projects.

Language-Specific¶

• Go: controls my Go workflow in VS Code, with formatting, language server support, linting, and navigation that make quick edits feel frictionless.
• Python: handles the Python environment and editor integration that I still want available, even if deeper Python work often moves to PyCharm.
• Pylance: gives Python its real intelligence layer, especially around type analysis, symbol navigation, and better completions.
• PowerShell: provides the best PowerShell editing experience available, and it is non-negotiable if you write more than a few scripts a week.
• HashiCorp Terraform: adds HCL awareness, validation, and formatting so Terraform files stop feeling like plain text.
• HashiCorp HCL: fills in the gaps around HCL syntax support and makes infrastructure files much nicer to edit.
• Red Hat YAML: provides schema-aware YAML editing, which saves me from a lot of avoidable indentation and key mistakes.
• Red Hat Ansible: is useful whenever automation work crosses into playbooks and inventories.
• Trunk: acts as a practical formatter and quality gate in places where I want one tool orchestrating the boring cleanup work.

Quality of Life¶

• Material Icon Theme: makes the Explorer easier to parse at a glance, which sounds trivial until you spend all day living in it.
• Code Spell Checker: catches the kind of embarrassing typos that linters miss and blog readers definitely notice.
• Markdownlint: keeps Markdown honest, especially across longer technical posts and documentation.
• Markdown All in One: adds just enough Markdown ergonomics to make writing feel smoother without turning the editor into a Swiss Army knife.
• Reflow Markdown: helps me keep paragraphs wrapped cleanly at the widths I actually want.
• CodeSnap: turns code into polished screenshots when I need to share something visually.
• TabOut: makes moving through quotes, brackets, and other paired characters feel much less annoying.

The Settings That Actually Matter¶

Extensions get the attention, but settings are where the setup becomes personal. These are the tweaks that most define how my VS Code behaves day to day.

Core Editor Defaults¶

This is the heart of the setup: readable text, low clutter, and automatic cleanup where it makes sense.

{
  "editor.fontFamily": "FiraCode",
  "editor.fontLigatures": true,
  "editor.fontSize": 17,
  "editor.minimap.enabled": false,
  "editor.rulers": [120],
  "editor.cursorStyle": "line-thin",
  "editor.cursorBlinking": "phase",
  "editor.cursorSmoothCaretAnimation": "on",
  "editor.bracketPairColorization.enabled": true,
  "editor.guides.bracketPairs": true,
  "editor.inlineSuggest.enabled": true,
  "editor.defaultFormatter": "esbenp.prettier-vscode",
  "editor.formatOnSaveMode": "modificationsIfAvailable",
  "files.insertFinalNewline": true,
  "files.trimTrailingWhitespace": true,
  "workbench.editor.enablePreview": false,
  "workbench.startupEditor": "none"
}

A few of these are especially important to me:

• editor.minimap.enabled: false because I hate visual clutter more than I love tiny file previews.
• editor.formatOnSaveMode: "modificationsIfAvailable" because it keeps formatting targeted, which is kinder to blame history and large shared files.
• files.trimTrailingWhitespace: true and files.insertFinalNewline: true because basic file hygiene should be automatic, not aspirational.
• workbench.editor.enablePreview: false because I want open tabs to stay open until I close them.

Theme and Icon Setup¶

These are the settings that give the editor its personality. Material Icon Theme itself is enabled through the UI, and the setting I keep pinned is the React/Redux icon pack.

{
  "workbench.preferredDarkColorTheme": "Dracula",
  "workbench.preferredLightColorTheme": "Dracula",
  "workbench.preferredHighContrastColorTheme": "Dracula",
  "material-icon-theme.activeIconPack": "react_redux"
}

Yes, I use Dracula for everything. Once I settle into a theme I like, I would rather keep the visual language consistent than bounce around chasing novelty.

Git and GitHub¶

A lot of my day runs through Git, GitHub, reviews, and automation, so I want those defaults to be helpful without nagging me.

{
  "git.autofetch": true,
  "git.confirmSync": false,
  "git.enableCommitSigning": true,
  "git.enableSmartCommit": true,
  "git.alwaysSignOff": true,
  "githubPullRequests.useReviewMode": "auto",
  "githubPullRequests.pushBranch": "always",
  "githubPullRequests.quickDiff": true
}

This setup keeps Git moving. Autofetch keeps repository state fresh, commit signing stays on by default, and the GitHub PR settings reduce a bunch of small review-time friction.

AI and Inline Assistance¶

I use AI features, but I am selective about where I want them showing up.

{
  "chat.agent.enabled": true,
  "chat.agent.maxRequests": 100,
  "github.copilot.editor.enableAutoCompletions": true,
  "github.copilot.nextEditSuggestions.enabled": true,
  "github.copilot.enable": {
    "*": true,
    "markdown": false,
    "plaintext": true,
    "scminput": false
  }
}

This is a good example of why settings matter more than a raw extension list. I like Copilot in code. I do not want it trying to finish my commit messages for me, and I don't want it interfering with long-form Markdown writing where voice matters more than speed.

Language-Specific Formatting¶

I keep global defaults sane, then tighten things up per language where it matters. Think of this as the shape of the configuration, not a full dump of every language-specific tweak in my settings file.

{
  "[go]": {
    "editor.defaultFormatter": "golang.go",
    "editor.formatOnPaste": true,
    "editor.formatOnSave": true,
    "editor.formatOnType": true,
    "editor.wordWrapColumn": 120
  },
  "[python]": {
    "editor.defaultFormatter": "trunk.io"
  },
  "[powershell]": {
    "editor.defaultFormatter": "ms-vscode.powershell",
    "editor.formatOnPaste": true,
    "editor.formatOnSave": true,
    "editor.formatOnType": true,
    "editor.wordWrap": "off"
  },
  "[terraform]": {
    "editor.defaultFormatter": "hashicorp.terraform",
    "editor.formatOnPaste": true,
    "editor.formatOnSave": true,
    "editor.formatOnType": true
  },
  "[markdown]": {
    "editor.defaultFormatter": "DavidAnson.vscode-markdownlint",
    "editor.formatOnSave": false,
    "editor.wordWrap": "bounded",
    "editor.wordWrapColumn": 100
  }
}

This is one of my favorite parts of the whole setup because it reflects how I actually work:

• Go gets full formatting support because the ecosystem rewards consistency
• PowerShell gets its own formatting behavior because pipeline-heavy scripts need different treatment
• Terraform should always be formatted cleanly
• Markdown is the exception, not the rule, because I want control over prose and line wrapping

Terminal Integration¶

I also want the terminal inside VS Code to feel like my terminal, not a second-class imitation of it.

{
  "terminal.integrated.defaultProfile.osx": "zsh",
  "terminal.integrated.fontFamily": "FiraCode",
  "terminal.integrated.fontSize": 16,
  "terminal.integrated.shellIntegration.decorationsEnabled": "gutter",
  "terminal.explorerKind": "external",
  "terminal.external.osxExec": "iTerm2.app"
}

That gives me a solid integrated terminal when I want it, while still making it easy to kick out to iTerm2 when I want a full terminal session.

Backup and Synchronization¶

The backbone of this setup is VS Code Settings Sync. I sign in with GitHub and let VS Code sync the things that matter: settings, extensions, keybindings, and profiles. That means a new machine isn't really a fresh start, it is mostly a sign-in event.

I also use profiles, which gives me a little extra flexibility without turning the editor into chaos. Right now I have a synced Doc Writer profile, and I like having that profile information travel with the rest of the environment.

For extra resilience, I still think in terms of setup-as-code wherever it makes sense:

• Workspace-specific settings belong in the repository when they help collaborators, like .vscode recommendations or a .devcontainer/devcontainer.json
• My user settings are simple JSON and easy to export, diff, and restore if I ever need to rebuild manually
• Extension sync matters as much as settings sync, because a perfect settings.json without the right tooling is only half a setup

That combination is enough to make the environment portable without becoming precious about it.

What I like about VS Code isn't that it can be customized endlessly. It is that, after a little care, it can start feeling invisible. The editor stops getting in the way and starts reinforcing how you already like to work.

This setup is mine. Yours should absolutely reflect your own stack, your own habits, and your own annoyances. But if you are tuning your editor and looking for ideas, hopefully there is something in here worth stealing.

If you have a favorite extension or a weirdly specific settings.json tweak you swear by, I would love to hear about it.