Setting Up Windows 11 for Development

I recently did a clean install of Windows 11, which meant setting up a development environment from scratch all over again. This guide is the map I wish I'd had in front of me: the order I'd do things in, what actually matters, and where to go deeper on each piece.

It's deliberately a hub. Rather than cramming every detail into one enormous page, each section covers the what and the why at a high level, then points you to a dedicated guide for the step-by-step where I've written one. Follow it top to bottom on a fresh install and you'll end up with a clean, capable dev machine.

The order matters

Before the steps, here's the logic of the sequence, because doing these in the right order saves you redoing work:

1. Update and clean up first — you want a fully-patched, de-cluttered base before installing anything on top of it.
2. Turn on the system features — WSL2, virtualization, developer mode. These sometimes need reboots, so batch them early.
3. Get a package manager working — once winget is set up, everything after this becomes a copy-paste command instead of hunting for installers.
4. Install your tools — Git, a terminal, an editor — using that package manager.
5. Polish — fonts, prompt theming, quality-of-life settings.

Part 1: Update and Clean Up

Run Windows Update to completion

Before anything else, get fully patched. A fresh install is almost always behind on updates, and some later steps (especially WSL2 and virtualization features) behave better on a current build.

Go to Settings → Windows Update → Check for updates, install everything, reboot, and check again. Repeat until it comes back clean. It often takes two or three rounds.

Trim the preinstalled bloat

Windows 11 ships with a fair amount of software you probably don't want on a dev machine. Go through Settings → Apps → Installed apps and uninstall what you won't use — the pre-bundled games, trial software, and promotional apps.

Quick privacy and telemetry pass

Under Settings → Privacy & security, it's worth a few minutes going through the permissions and diagnostic-data settings and dialing back anything you're not comfortable with. This is personal preference — there's no single "correct" configuration — but a fresh install is the natural time to set it.

Power settings for a dev machine

A development machine (especially a desktop, or a laptop that's often plugged in) usually shouldn't be aggressively sleeping. Under Settings → System → Power, set the sleep timeouts to something sensible for how you work — or "Never" for sleep on a plugged-in desktop that runs long tasks.

Quality-of-life settings

While you're in Settings, a few changes that make daily life nicer:

• Dark mode (Settings → Personalization → Colors) if that's your preference — easier on the eyes for long sessions.
• Show file extensions — open File Explorer → View → Show → File name extensions. As a developer you want to see whether a file is a .txt, .ps1, or .exe. This one is genuinely important, not just cosmetic.
• Display scaling — if text is too small or large, adjust under Settings → System → Display → Scale.

Part 2: Turn On the Developer Foundations

These are Windows features that are off (or partially off) by default and underpin a lot of development work. Enabling them early — while you're already rebooting for updates — saves friction later.

Enable Developer Mode

Settings → System → For developers → Developer Mode → On. This relaxes a few restrictions (like allowing app sideloading and making symbolic links easier to create) that development workflows occasionally need.

Windows Terminal

Windows Terminal is the modern, tabbed terminal app — a huge upgrade over the old Command Prompt window. On Windows 11 it's usually the default terminal already, but confirm it's installed and current (it's in the Microsoft Store, or install it via winget in the next section). We'll come back to configuring it once the shell is set up.

WSL2 — Linux inside Windows

This is the big one for most development work. WSL2 (Windows Subsystem for Linux 2) runs a real Linux environment directly inside Windows, which is where a lot of modern tooling — Docker, many language runtimes, most server-side work — feels most at home.

Enabling it is a single command, but there's enough to say about why and how to set it up well (including running Docker inside it) that it has its own full guide:

→ Setting Up a Development Environment with WSL2 and Docker on Windows 11

That guide walks through enabling WSL2, installing Ubuntu, running Docker natively inside it, and connecting VS Code — start there for the Linux side of your environment.

Virtualization (optional — for VMs)

If you plan to run virtual machines (for a homelab, for testing, for malware analysis, etc.), you'll want the virtualization features enabled. On Windows 11 Pro that means Hyper-V, which you can turn on under Control Panel → Programs → Turn Windows features on or off → Hyper-V. Note that WSL2 uses the same underlying virtualization platform, so the two coexist fine.

Part 3: Package Management with winget

This is the section that changes how you install everything else.

winget is Windows' built-in package manager — it comes with Windows 11. Instead of opening a browser, searching for a tool's website, downloading an installer, and clicking through it, you run one command and winget fetches and installs the software for you. It's the same idea as apt on Ubuntu or brew on macOS.

Confirm winget is available

Open Windows Terminal (or PowerShell) and run:

winget --version

If it prints a version number, you're set. If not, install "App Installer" from the Microsoft Store, which provides winget.

The basic commands

# Search for a package
winget search <name>

# Install a package
winget install <name>

# List installed packages winget knows about
winget list

# Upgrade everything that has an update available
winget upgrade --all

Why this matters

From here on, every tool in this guide can be installed with a single command. That's not just convenient — it means your setup is reproducible. You can keep a list of winget install commands and rebuild your entire toolchain on a new machine in minutes. Some people script this into a single setup file; even just keeping the commands in a note is valuable.

Part 4: Version Control with Git

Git is non-negotiable for development. Install it with winget:

winget install Git.Git

Restart your terminal afterward so git is on your path, then confirm:

git --version

Set your identity

Before your first commit, tell Git who you are:

git config --global user.name "Your Name"
git config --global user.email "your-email@example.com"

There's more worth configuring — a default branch name, a sensible default editor, line-ending handling on Windows — plus the whole workflow of actually using Git and GitHub. That's covered in depth here:

→ Git and GitHub Guide

And when you're ready for branching workflows (which you'll want as soon as you're working on anything non-trivial):

→ Git Branches Guide

For a quick day-to-day command reference, keep this handy:

→ Git Cheat Sheet

SSH keys for GitHub

Rather than typing a password (or token) every time you push, set up SSH key authentication. It's more secure and far more convenient. The full walkthrough — generating a key, adding it to GitHub, and using it — is here:

→ How to Set Up SSH Keys

Part 5: Shell and Terminal Setup

PowerShell 7

Windows ships with "Windows PowerShell 5.1," but the modern, actively-developed version is PowerShell 7 (just called "PowerShell"). It's cross-platform, faster, and has features the old version lacks. Install it with winget:

winget install Microsoft.PowerShell

Once installed, you can set it as your default profile in Windows Terminal (Settings → Startup → Default profile → PowerShell).

A Nerd Font

Before theming your prompt, install a Nerd Font — a font patched to include the icons and glyphs that modern terminal prompts use. Without one, a themed prompt shows boxes and question marks where icons should be.

Popular choices include CaskaydiaCove, MesloLGS, or FiraCode Nerd Font. Many are available via winget, or from nerdfonts.com. After installing, set it as your terminal font in Windows Terminal's settings.

Prompt theming with Oh My Posh

A good prompt shows you useful context at a glance — current directory, Git branch and status, whether the last command succeeded. Oh My Posh is the tool for this on Windows, and I've written a full setup guide:

→ Oh My Posh Setup Guide

That covers installing it, picking a theme, wiring it into your PowerShell profile, and getting the fonts right so everything renders properly.

Part 6: Editor and Everything Else

VS Code

Visual Studio Code is the default editor for a huge portion of developers, and it integrates especially well with WSL2 (letting you edit Linux files with a full Windows editor). Install it with winget:

winget install Microsoft.VisualStudioCode

If you followed the WSL2 guide, you'll already have connected VS Code to your Linux environment there. The key extensions to start with are WSL and, if you're using containers, Dev Containers — both covered in that guide.

Browsers and dev tooling

Install whatever browser you develop against — the winget IDs for the common ones:

winget install Google.Chrome
winget install Mozilla.Firefox

Both ship with excellent built-in developer tools (F12) for inspecting pages, debugging JavaScript, and checking network requests.

Language runtimes — a note

This guide deliberately stops at the OS and tooling layer, because language setup is where things get personal and project-specific. Whether you need Node.js, Python, Go, Rust, or something else depends entirely on what you're building — and each deserves its own proper setup rather than a rushed mention here.

The one piece of general advice: on Windows, seriously consider installing language runtimes inside WSL2 rather than on Windows directly, especially for anything web or server oriented. You'll hit fewer path/permission headaches and match production environments more closely. The WSL2 guide sets you up for exactly that.

A Reproducible Setup

Once you've been through this, here's a habit worth adopting: keep your winget install commands in a note or a script. The next time you set up a machine — or if you ever need to rebuild this one — you can reinstall your entire toolchain in one pass instead of hunting down each tool again.

A minimal example of what that looks like:

# Core dev tools
winget install Git.Git
winget install Microsoft.PowerShell
winget install Microsoft.VisualStudioCode
winget install Google.Chrome

# ...add your own as you go

That single list is, in effect, documentation of your environment. It's the Windows equivalent of the dotfiles many developers keep — and future-you will thank present-you for maintaining it.

Where to Go Next

You now have a clean, capable Windows 11 development machine. Depending on what you're building, natural next steps:

• Linux fundamentals if WSL2 is new to you → Getting Started with Linux
• Understand containers if you'll use Docker → How Docker Containers Work
• A lightweight editor for the terminal → Neovim Without Plugins
• Writing documentation and notes → Markdown Guide

Set up once, set up properly, and you won't have to think about your environment again for a long time.