# General Development Windows Native Setup
A language-agnostic walkthrough for setting up a modern, native development environment on **Windows 11**, working identically on **ARM64 (Snapdragon, Surface Pro 11, Dev Kit 2023) and x64 (Intel/AMD)**. This is the Windows-native counterpart to [[General_Development_Mac_Tahoe_Setup]] and [[General_Development_Ubuntu_Setup]]. The pieces work together:
- **Windows Terminal** — the terminal emulator (what you see)
- **PowerShell 7** — the shell (what runs your commands)
- **Starship** — the prompt (what tells you where you are)
- **PSReadLine** — bash's `ble.sh` equivalent, ships with PowerShell 7 (syntax highlighting + autosuggestions, no extra install)
- **Git** — version control (covered in Prerequisites)
- **GitHub CLI** — publishing repos from the command line (covered in Prerequisites)
- **VS Code** — the editor (Part 6)
- **Claude Code** — the AI, everywhere (Part 7)
Each layer is independently swappable, but together they form a fast, low-friction stack with a single AI surface across both terminal and editor.
Once this is complete, add language support by following the individual guides:
- [[Python_Development_Windows_Native_Setup]]
- [[C_Development_Windows_Native_Setup]]
- [[Ruby_Development_Windows_Native_Setup]]
- [[Go_Development_Windows_Native_Setup]]
- [[Rust_Development_Windows_Native_Setup]]
Each language guide assumes this general setup is already in place and only adds language-specific tooling.
> [!tip] AI assistance is optional
> Part 7 of this guide sets up Claude Code as an AI assistant. **You can skip Part 7 entirely** and still have a complete, professional dev environment from Parts 1–6. If you prefer a different AI tool (GitHub Copilot, Cursor, Continue, Cline, Aider), Part 7 includes pointers for adapting the setup to those instead.
> [!info] One architecture, one set of instructions
> Everything below is chosen to install the same way on both Windows 11 ARM64 and x64. winget resolves the right binary for your CPU automatically; the few tools installed via official scripts (uv, rustup, Claude Code's optional fallback installer) detect your architecture themselves. You can confirm which architecture you're on at any time in PowerShell with `$env:PROCESSOR_ARCHITECTURE` (prints `AMD64` or `ARM64`).
> [!note] Considering WSL2 instead?
> The [[WSL2 Windows Development Setup|WSL2 path]] runs Ubuntu inside Windows and reuses the Linux guides. If most of your work targets Linux servers, containers, or CI runners, that path is often simpler. This native guide is the right choice when you're building Windows software, want zero Linux layer, or specifically target native ARM64 Windows.
---
## Prerequisites
Before starting, you should have:
- Windows 11 (Home, Pro, Education, or Enterprise), version 22H2 or newer, on ARM64 or x64
- A local administrator account for first-time installs (your everyday account doesn't need admin rights afterward)
- A working network connection
### Open the right PowerShell
There are two PowerShells on Windows. The built-in **Windows PowerShell 5.1** (`powershell.exe`) is what was preinstalled with Windows for decades. **PowerShell 7** (`pwsh.exe`) is the modern, cross-platform, faster, actively-developed version. We'll install it in Part 2 and use it as the default shell.
Until then, the built-in `powershell.exe` is what you'll type into. Open it: press `Win`, type `powershell`, press `Enter`.
### Confirm your architecture
```powershell
$env:PROCESSOR_ARCHITECTURE
```
- `AMD64` → x64 (Intel/AMD)
- `ARM64` → ARM (Snapdragon, Surface Pro 11, Dev Kit 2023)
Either way, all the commands below are the same.
### Confirm winget is installed
```powershell
winget --version
```
`winget` ships with every Windows 11 install via the **App Installer** Store package, and has native binaries for both ARM64 and x64. If it errors with "not recognized," wait 10–15 minutes after a fresh Windows install for the Store to push App Installer, then try again. If it's still missing, install "App Installer" from the Microsoft Store directly.
> [!info] Why winget, not Scoop or Chocolatey?
> The Mac guide uses Homebrew; Ubuntu uses apt. winget is the natural Windows equivalent — first-party, bundled with the OS, no warm-up, and ships native binaries for both architectures. Scoop and Chocolatey are both fine alternatives many people prefer; if you've already invested in one of them, the tools below are all available there too. winget is what this guide standardizes on.
### Build basics
Unlike Linux's `build-essential`, Windows doesn't have a single "compiler bundle" you install up front — each language guide installs its own toolchain (MSVC for C, MSVC stub for Rust, the Go toolchain, etc.). The general setup needs only a small set of utilities:
```powershell
# 7-Zip handles the assorted archive formats the rest of the setup pulls down
winget install -e --id 7zip.7zip
```
That's it for now. The language guides install everything else they need.
### Configuring Git
Install Git first — it backs everything else.
```powershell
winget install -e --id Git.Git
```
`winget install Git.Git` on an ARM64 host pulls the ARM64 build of Git for Windows; on x64 you get the x64 build. The Git binary also brings **Git Credential Manager (GCM)** — the secure credential store backed by the Windows Credential Manager (no extra install or compilation step like libsecret on Linux).
Open a **new** PowerShell window after install so `git` is on the PATH, then set Git up. These settings apply globally and only need to be set once per machine.
#### Identity
Every commit is stamped with a name and email. Use the same email you use for GitHub:
```powershell
git config --global user.name "Your Name"
git config --global user.email "
[email protected]"
```
> [!tip] If you use multiple identities
> If you commit to both personal and work repos, you can override `user.email` per-repo later with `git config user.email "
[email protected]"` inside that repo's directory.
#### Modern defaults
```powershell
# Use 'main' as the default branch name for new repos
git config --global init.defaultBranch main
# On 'git pull', fast-forward if possible; otherwise merge (don't rebase)
git config --global pull.rebase false
# On 'git push' for a new branch, automatically set upstream
git config --global push.autoSetupRemote true
# Colored output in status, diff, etc.
git config --global color.ui auto
# Use VS Code as the default editor for commit messages
# (We'll install VS Code in Part 6 — this line can be run now or later)
git config --global core.editor "code --wait"
# Keep CRLF out of repositories — strongly recommended if you ever touch
# files that will also be opened in Linux/Mac tools or run inside containers
git config --global core.autocrlf input
```
> [!info] `core.autocrlf`
> Windows traditionally uses CRLF line endings; Linux and Mac use LF. The historical default of `core.autocrlf=true` rewrites LF to CRLF on checkout and back to LF on commit — which is fine for purely-Windows projects but causes pain in mixed environments. `input` is the modern recommendation: leave files alone on the filesystem, normalize to LF on commit. If you ever work in a Linux container, WSL, or with a remote team on macOS/Linux, this saves a lot of trouble.
#### Credential storage (Git Credential Manager)
GCM was bundled with Git for Windows. Confirm it's configured:
```powershell
git config --global credential.helper
# Should print: manager
```
If empty, set it:
```powershell
git config --global credential.helper manager
```
On first push to an HTTPS remote (e.g., a GitHub repo), GCM pops up a browser-based login. The credentials land in **Windows Credential Manager** (the same Windows store that holds your Wi-Fi passwords). No plaintext file, no separate keyring service to compile.
> [!info] No keyring server needed
> macOS uses Keychain, Linux uses libsecret backed by GNOME Keyring (which has to be running). Windows Credential Manager is part of the OS and always available — no service to start, no compile step.
#### Useful quality-of-life config
```powershell
# Auto-correct obvious typos like 'git stauts' → 'git status'
git config --global help.autocorrect 20
# Prune deleted remote branches when fetching
git config --global fetch.prune true
# Show diff stats in commit message editor
git config --global commit.verbose true
# Better diff algorithm for code
git config --global diff.algorithm histogram
# Reuse conflict resolutions (magic — turn this on and forget about it)
git config --global rerere.enabled true
```
#### SSH key for GitHub
HTTPS with GCM works fine, but SSH is the GitHub convention and avoids repeated browser prompts.
Windows 11 ships **OpenSSH** as an optional Windows feature, and it's installed by default on current builds. Confirm:
```powershell
ssh -V
```
If `ssh` isn't found, install the optional feature:
```powershell
# (Elevated PowerShell)
Add-WindowsCapability -Online -Name OpenSSH.Client~~~~0.0.1.0
```
Generate a key and start the agent:
```powershell
# Generate ED25519 key
ssh-keygen -t ed25519 -C "
[email protected]"
# Accept the default location (~\.ssh\id_ed25519) and set a passphrase
# Start the ssh-agent service (run once, persists across reboots)
Get-Service ssh-agent | Set-Service -StartupType Automatic
Start-Service ssh-agent
# Add the key to the agent — you'll be asked for the passphrase once
ssh-add $HOME\.ssh\id_ed25519
```
The agent stores the unlocked key in memory and survives reboots (the service auto-starts), so you'll only enter the passphrase once after each fresh Windows boot — and Windows' built-in agent persists it across sessions until reboot.
Optionally, add an SSH config that pins this key for GitHub:
```powershell
# Create ~/.ssh/config (PowerShell)
$ssh_config = @"
Host github.com
AddKeysToAgent yes
IdentityFile ~/.ssh/id_ed25519
"@
Add-Content -Path $HOME\.ssh\config -Value $ssh_config
```
Copy the public key to the clipboard and paste it at <https://github.com/settings/keys>:
```powershell
Get-Content $HOME\.ssh\id_ed25519.pub | Set-Clipboard
```
Test:
```powershell
ssh -T
[email protected]
# Should say: "Hi yourusername! You've successfully authenticated..."
```
#### Verify
```powershell
git config --global --list
```
Should show everything you just set. If you ever need to edit by hand, the file lives at `~/.gitconfig` (PowerShell expands `~` to `$HOME`, which is your user profile directory).
### Publishing a repo to GitHub
`git` itself only manages local repositories. Creating a *new* repository on GitHub's servers requires either the web UI or the `gh` CLI. The CLI is faster and keeps you in the terminal.
#### Install and authenticate GitHub CLI
```powershell
winget install -e --id GitHub.cli
```
ARM64 and x64 binaries both ship. Open a new PowerShell window so `gh` is on the PATH, then authenticate:
```powershell
gh auth login
```
`gh auth login` walks through an interactive prompt. Recommended answers:
- **GitHub.com** (not Enterprise)
- **HTTPS** as the Git protocol (GCM stores the credentials)
- **Login with a web browser** (opens github.com, you paste a one-time code shown in the terminal, done)
After auth, configure `gh` as Git's credential helper:
```powershell
gh auth setup-git
```
> [!info] SSH vs HTTPS for `gh`
> If you already set up SSH keys above, you can choose SSH during `gh auth login` instead. Either works. HTTPS is slightly less friction because `gh` manages credentials through GCM automatically; SSH is the GitHub convention.
#### Create a new GitHub repo from an existing local repo
From inside any directory that already has a local git repo with at least one commit:
```powershell
gh repo create myproject --public --source=. --remote=origin --push
```
Flag breakdown:
| Flag | Purpose |
|------|---------|
| `myproject` | Name of the new GitHub repo |
| `--public` | Visibility. Use `--private` for private, `--internal` for org-only |
| `--source=.` | Use the current directory's existing local repo as the source |
| `--remote=origin` | Name the new remote "origin" (git convention) |
| `--push` | Push the current branch immediately after creating the remote |
Verify by opening it in your browser:
```powershell
gh repo view --web
```
#### The full new-project workflow
```powershell
# Create and initialize locally
mkdir $HOME\projects -ErrorAction SilentlyContinue
cd $HOME\projects
mkdir myproject
cd myproject
# <language-specific init>
# Python: uv init --python 3.13
# Rust: cargo init
# Go: go mod init github.com/you/myproject
# Ruby: bundle init
# C: ni main.c, ni CMakeLists.txt
# Typical .gitignore (language-specific; each language guide covers what to add)
ni .gitignore
git init
git add .
git commit -m "Initial commit"
# Create on GitHub and push (assumes `gh` is authenticated)
gh repo create myproject --private --source=. --remote=origin --push
```
#### Day-to-day after the initial push
```powershell
# Edit files...
git add .
git commit -m "Add feature X"
git push
```
Because your `.gitconfig` has `push.autoSetupRemote = true`, the first push on any new branch automatically sets upstream tracking.
#### Useful `gh` commands
```powershell
gh repo view
gh repo view --web
gh repo clone owner/name
gh repo list
gh pr create
gh pr list
gh issue create
gh issue list
gh auth status
```
---
## Part 1 — Installing Windows Terminal
> [!info] Why Windows Terminal, not Ghostty or WezTerm?
> Ghostty has **no official Windows build** as of June 2026. WezTerm has no native Windows ARM64 build. Windows Terminal is Microsoft's first-party, modern, GPU-accelerated, ARM64-native terminal — it ships with Windows 11, supports profiles for every shell on your system, and has a perfectly good config story (a single JSON file).
### Install
Windows Terminal usually comes preinstalled on Windows 11. Confirm or install:
```powershell
winget install -e --id Microsoft.WindowsTerminal
```
Launch it once from the Start menu so it registers as the default terminal.
### Make it the default
In Windows Settings → **System → For developers → Terminal**, pick **Windows Terminal**. (Or open Terminal's own Settings → Startup → "Default terminal application" → Windows Terminal.) After this, any program that opens a console window (Python REPL launched from Explorer, `cmd` triggered by a tool, etc.) appears in a Windows Terminal tab.
### Config file location
Windows Terminal reads a single JSON file at:
```
%LOCALAPPDATA%\Packages\Microsoft.WindowsTerminal_8wekyb3d8bbwe\LocalState\settings.json
```
Open it from inside Terminal: **Settings** (`Ctrl+,`) → click the gear icon at the bottom-left → **Open JSON file**. Or jump to it directly:
```powershell
notepad "$env:LOCALAPPDATA\Packages\Microsoft.WindowsTerminal_8wekyb3d8bbwe\LocalState\settings.json"
```
Most settings can also be edited via the GUI in Terminal Settings.
### Install the Nerd Font
The Starship prompt you'll set up in Part 2 uses programming glyphs (git branch icons, language logos, folder icons) that only render in a **Nerd Font**. Install MesloLG (the same one used in the Mac and Ubuntu guides):
1. Download `Meslo.zip` from [Nerd Fonts releases](https://github.com/ryanoasis/nerd-fonts/releases/latest)
2. Extract the zip
3. Select all `.ttf` files (or just the Mono variants), right-click → **Install for all users**
Nerd Fonts are font files (architecture-independent), so the same zip works on ARM64 and x64.
Alternatives — download the matching zip from the [Nerd Fonts releases](https://github.com/ryanoasis/nerd-fonts/releases) page:
- `JetBrainsMono.zip` — clean, very popular
- `FiraCode.zip` — programming ligatures
- `Hack.zip` — dense, compact
- `CascadiaCode.zip` — Microsoft's own programming font, the Windows Terminal default
Confirm the family is registered — in PowerShell:
```powershell
[System.Drawing.Text.InstalledFontCollection]::new().Families |
Where-Object { $_.Name -like "*Meslo*" -or $_.Name -like "*Nerd*" } |
Select-Object Name
```
### A recommended starter `settings.json`
Paste the [[_resources/configs/windows-terminal-settings.json|companion Windows Terminal settings]] in place of the existing JSON (or merge with what's there). The key bits, with comments:
```jsonc
{
// ── Global ────────────────────────────────────────────────
"defaultProfile": "{574e775e-4f2a-5b96-ac1e-a2962a402336}", // PowerShell 7 — see "GUID" note below
"copyOnSelect": true,
"copyFormatting": "none",
"wordDelimiters": " /\\()\"'-:,.;<>~!@#$%^&*|+=[]{}~?│",
"useAcrylicInTabRow": true,
"showTabsInTitlebar": true,
"tabWidthMode": "compact",
"scrollbarState": "hidden",
"alwaysShowTabs": true,
"experimental.rendering.forceFullRepaint": false,
// ── Profile defaults applied to every profile ─────────────
"profiles": {
"defaults": {
"fontFace": "MesloLGM Nerd Font Mono",
"fontSize": 12,
"colorScheme": "Campbell Powershell",
"padding": "12, 12, 12, 12",
"useAcrylic": true,
"opacity": 97,
"cursorShape": "filledBox",
"snapOnInput": true,
"antialiasingMode": "cleartype",
"scrollbarState": "hidden"
},
"list": [
// Generated profiles (PowerShell 7, Windows PowerShell, Command Prompt,
// Azure Cloud Shell, any installed WSL distros) appear here automatically.
]
},
// ── Key bindings ──────────────────────────────────────────
"actions": [
{ "command": { "action": "splitPane", "split": "vertical" }, "keys": "ctrl+shift+o" },
{ "command": { "action": "splitPane", "split": "horizontal" }, "keys": "ctrl+shift+e" },
{ "command": { "action": "togglePaneZoom" }, "keys": "ctrl+shift+enter" },
{ "command": { "action": "closePane" }, "keys": "ctrl+shift+w" },
{ "command": { "action": "moveFocus", "direction": "left" }, "keys": "alt+h" },
{ "command": { "action": "moveFocus", "direction": "right" }, "keys": "alt+l" },
{ "command": { "action": "moveFocus", "direction": "up" }, "keys": "alt+k" },
{ "command": { "action": "moveFocus", "direction": "down" }, "keys": "alt+j" }
]
}
```
> [!info] About the `defaultProfile` GUID
> The GUID above (`{574e775e-...}`) is the well-known stable identifier for the PowerShell 7 profile that Windows Terminal auto-generates when PowerShell 7 is installed. After you install PowerShell 7 in Part 2 and restart Terminal, this default will resolve correctly. Until then, Terminal will fall back to Windows PowerShell 5.1.
### Useful Terminal commands
- `Ctrl+,` — open Settings (GUI)
- `Ctrl+Shift+T` — new tab in default profile
- `Ctrl+Shift+T` then click the **down arrow** in the tab bar — pick a specific profile (Ubuntu in WSL, PowerShell 5.1, cmd, etc.)
- `Ctrl++` / `Ctrl+-` — zoom in / out
- `Ctrl+Shift+F` — fuzzy search in scrollback (very handy)
---
## Part 2 — PowerShell 7, Starship, and PSReadLine
### Install PowerShell 7
The shell that ships with Windows is **Windows PowerShell 5.1**, which is in maintenance mode. **PowerShell 7** (`pwsh.exe`) is the modern cross-platform replacement — faster, gets monthly releases, and is what every modern guide assumes.
```powershell
winget install -e --id Microsoft.PowerShell
```
Open a new tab in Windows Terminal — the dropdown now has a **PowerShell** entry (the 7.x one) in addition to **Windows PowerShell** (5.1). The 7.x one is what `defaultProfile` in the Terminal settings above points to; from now on, "PowerShell" in this guide means PowerShell 7 (`pwsh`).
### Confirm PSReadLine is current
**PSReadLine** is the PowerShell module that provides line editing — syntax highlighting, history-based autosuggestions (the ghost-text suggestions zsh users know), and emacs/vim keymaps. PowerShell 7 ships PSReadLine bundled, but it's worth ensuring you have the current release:
```powershell
Install-Module -Name PSReadLine -AllowPrerelease -Scope CurrentUser -Force -SkipPublisherCheck
```
> [!info] PSReadLine is the bash `ble.sh` equivalent
> The Linux guide installs `ble.sh` separately to get green/red command coloring and grey ghost-text suggestions in bash. PowerShell 7 has all of that built in via PSReadLine — no second install, no two-line `~/.bashrc` dance.
### Install Starship
Starship is a cross-shell prompt, written in Rust, with native ARM64 + x64 Windows binaries.
```powershell
winget install -e --id Starship.Starship
```
Open a new PowerShell window after install so `starship` is on the PATH.
### Wire Starship and PSReadLine into the PowerShell profile
PowerShell's per-user startup file is called `$PROFILE`. PowerShell 7's `$PROFILE` lives at:
```
$HOME\Documents\PowerShell\Microsoft.PowerShell_profile.ps1
```
(Note: PowerShell 5.1's profile is in `WindowsPowerShell\` — a separate file. We only care about the PowerShell 7 one.)
Create it if it doesn't exist:
```powershell
if (-not (Test-Path $PROFILE)) { New-Item -Type File -Path $PROFILE -Force }
```
Then paste in the [[_resources/configs/powershell-profile.ps1|companion `$PROFILE`]], or use this as a starting point. Open it for editing:
```powershell
code $PROFILE
```
```powershell
# ── PSReadLine: behavior + colors ───────────────────────────
Import-Module PSReadLine
# Emacs keybinds (Ctrl-A start of line, Ctrl-E end of line, etc.).
# Use 'Windows' if you prefer cmd-style key bindings.
Set-PSReadLineOption -EditMode Emacs
# Show grey ghost-text command suggestions from history (zsh-autosuggestion style)
Set-PSReadLineOption -PredictionSource HistoryAndPlugin
Set-PSReadLineOption -PredictionViewStyle ListView
# Syntax-color the command line as you type
Set-PSReadLineOption -Colors @{
Command = '#7AA2F7'
Parameter = '#BB9AF7'
Operator = '#89DDFF'
Variable = '#E0AF68'
String = '#9ECE6A'
Number = '#FF9E64'
Type = '#7DCFFF'
Comment = '#565F89'
InlinePrediction = '#3B4261'
ContinuationPrompt = '#3B4261'
}
# Better history search (Ctrl+R / Ctrl+S — fuzzy-style)
Set-PSReadLineKeyHandler -Key Ctrl+r -Function ReverseSearchHistory
Set-PSReadLineKeyHandler -Key Ctrl+s -Function ForwardSearchHistory
# Tab brings up an interactive menu instead of cycling
Set-PSReadLineKeyHandler -Key Tab -Function MenuComplete
# ── Starship prompt ─────────────────────────────────────────
Invoke-Expression (&starship init powershell)
# ── PATH additions ──────────────────────────────────────────
# Put per-user bin first so locally-installed tools win
$env:PATH = "$HOME\.local\bin;" + $env:PATH
# ── Aliases (created by Modern CLI replacements — Part 5) ───
# These are added once you've installed the replacements; safe to leave
# uncommented now and add the tools later.
# Set-Alias ls eza
# Set-Alias cat bat
# Set-Alias find fd
# ── Useful functions ────────────────────────────────────────
function which { param($cmd) (Get-Command $cmd).Source }
function .. { Set-Location .. }
function ... { Set-Location ..\.. }
function mkcd { param($d) New-Item -Type Directory -Path $d | Out-Null; Set-Location $d }
# ── Welcome ─────────────────────────────────────────────────
# Run when this profile loads; cheap and quiet — comment out if it bothers you.
# Write-Host "PowerShell $($PSVersionTable.PSVersion) — $env:PROCESSOR_ARCHITECTURE" -ForegroundColor DarkGray
```
Reload the profile (or just open a new tab):
```powershell
. $PROFILE
```
You should immediately see Starship's prompt. If glyphs look like boxes or question marks, your Windows Terminal font isn't a Nerd Font — revisit Part 1's "Install the Nerd Font" step.
### Configure Starship
Starship's config file lives at:
```
$HOME\.config\starship.toml
```
Create it:
```powershell
mkdir $HOME\.config -ErrorAction SilentlyContinue
ni $HOME\.config\starship.toml
code $HOME\.config\starship.toml
```
Paste in the [[_resources/configs/starship.toml|companion Starship config]]. The same config used on Mac and Ubuntu works on Windows — Starship is cross-platform:
```toml
# ── Overall format ────────────────────────────────────────────
# Two-line prompt: info on top, clean input line below.
format = """
$directory\
$git_branch\
$git_status\
$python\
$c\
$rust\
$golang\
$ruby\
$nodejs\
$cmd_duration\
$line_break\
$character"""
[character]
success_symbol = "[❯](bold green)"
error_symbol = "[❯](bold red)"
vimcmd_symbol = "[❮](bold green)"
[directory]
truncation_length = 3
truncate_to_repo = true
style = "bold cyan"
[git_branch]
symbol = " "
style = "bold purple"
[git_status]
style = "bold yellow"
format = '([\[$all_status$ahead_behind\]]($style) )'
# Language modules — each only shows when a relevant file is in the directory
[python]
symbol = " "
style = "bold yellow"
format = '[${symbol}${pyenv_prefix}(${version})(\($virtualenv\) )]($style)'
[c]
symbol = " "
style = "149 bold"
format = '[$symbol($version(-$name) )]($style)'
[rust]
symbol = " "
style = "bold red"
format = '[$symbol($version )]($style)'
[golang]
symbol = " "
style = "bold cyan"
format = '[$symbol($version )]($style)'
[ruby]
symbol = " "
style = "bold red"
format = '[$symbol($version )]($style)'
[cmd_duration]
min_time = 2000
style = "bold yellow"
format = "took [$duration]($style) "
[aws]
disabled = true
[gcloud]
disabled = true
[nodejs]
detect_files = ["package.json"]
```
### Why the language modules matter
When you `cd` into a project directory, Starship detects the language based on files present and shows:
- **Python project** (has `.py`, `pyproject.toml`, or `.python-version`) → Python version + active venv
- **C project** (has `.c` or `CMakeLists.txt`) → Compiler version
- **Rust project** (has `Cargo.toml`) → Rust version
- **Go project** (has `.go` or `go.mod`) → Go version
- **Ruby project** (has `.rb`, `Gemfile`, or `.ruby-version`) → Ruby version
Reading the prompt left-to-right tells you which toolchain will run your next command, before you type.
### Useful Starship commands
```powershell
starship explain
starship print-config
starship module python
starship preset list
starship preset gruvbox-rainbow | Out-File -Encoding utf8 $HOME\.config\starship.toml
```
---
## Part 3 — How It All Fits Together
```
┌─────────────────────────────────────────────────────────────┐
│ Windows Terminal (DirectX-rendered, ARM64 or x64) │
│ ┌───────────────────────────────────────────────────────┐ │
│ │ PowerShell 7 (pwsh.exe) │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ PSReadLine (syntax + suggestions, built in) │ │ │
│ │ │ Starship prompt │ │ │
│ │ │ ~\projects\demo main <lang version> │ │ │
│ │ │ ❯ <your commands> │ │ │
│ │ │ ┌───────────────────────────────────────────┐ │ │ │
│ │ │ │ Language toolchain (uv, cargo, go, etc.) │ │ │ │
│ │ │ └───────────────────────────────────────────┘ │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ └───────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
```
### A day-in-the-life example
```powershell
# Create a new project
cd $HOME\projects
mkdir demo; cd demo
# <language-specific init> (uv init, cargo new, go mod init, etc.)
# Prompt shows: projects\demo <lang version> ❯
git init
git add .
git commit -m "Initial commit"
# After editing files, the prompt updates to show dirty state:
# projects\demo main [!] <lang version> ❯
# Commit, push, and the prompt returns to clean
git add .; git commit -m "Add feature X"
gh repo create demo --private --source=. --remote=origin --push
```
Every piece of the prompt has a job:
- **Directory** → where am I
- **Git branch + status** → what's the repo state
- **Language version** → which toolchain will run my next command
---
## Part 4 — Colors: Terminal vs Shell vs Prompt
A common point of confusion: **setting a Windows Terminal color scheme does not, by itself, control how PowerShell colors output.** These are separate layers.
### The three layers
| Layer | What it controls | Configured in |
|-------|------------------|---------------|
| **Terminal palette** | The 16 ANSI color slots + foreground/background. "When a program asks for color 34, render it as *this blue*." | Windows Terminal `colorScheme` |
| **Output / `ls` colors** | Which color PowerShell uses for directories, executables, etc. when it prints | `$PSStyle.FileInfo`, eza, bat |
| **Line-editor coloring** | Syntax-highlighting of commands as you type, green/red, ghost text | PSReadLine (`Set-PSReadLineOption -Colors @{...}`) |
> [!info] PowerShell 7 has built-in file-type colors
> Modern PowerShell colors directory listings via `$PSStyle.FileInfo` automatically — directories appear in one color, executables in another, etc. Run `Get-ChildItem` (or its alias `ls`) in any folder and you'll already see this. You can customize the colors:
> ```powershell
> $PSStyle.FileInfo.Directory = "`e[34m" # blue
> $PSStyle.FileInfo.Executable = "`e[32m" # green
> $PSStyle.FileInfo.SymbolicLink = "`e[36m" # cyan
> # Add to $PROFILE to persist.
> ```
### Better `ls` with `eza`
`eza` is the modern `ls` replacement with richer colors, a git-status column, and file-type icons. ARM64 + x64 binaries both ship via winget:
```powershell
winget install -e --id eza-community.eza
```
Add to `$PROFILE` (alongside the lines from Part 2):
```powershell
function Get-ChildItemEza { eza --group-directories-first --icons @args }
function Get-ChildItemLong { eza -lah --group-directories-first --git --icons @args }
function Get-ChildItemTree { eza --tree --level=3 --git-ignore --icons @args }
Set-Alias -Name ls -Value Get-ChildItemEza -Force -Option AllScope
Set-Alias -Name ll -Value Get-ChildItemLong
Set-Alias -Name tree -Value Get-ChildItemTree
```
> [!info] Why `function` + `Set-Alias -Option AllScope`
> PowerShell aliases can't carry default arguments, so to pass `--group-directories-first --icons` automatically we wrap eza in a function and alias to it. `-Option AllScope` makes `ls` work inside other modules too (some modules import their own `ls`).
### Line-editor coloring — already done by PSReadLine
Unlike bash (where you install `ble.sh` separately), PowerShell 7 ships with PSReadLine, and the `$PROFILE` block in Part 2 already configures the colors. You'll see:
```
❯ git status ← all colored (commands light blue, args grey)
❯ gti status ← "gti" in red (typo / not on PATH)
❯ git sta ← "git" colored, "tus" grey ghost text (press → to accept)
```
### Testing your color setup
```powershell
# 16-color test
0..15 | ForEach-Object { Write-Host -NoNewline ("`e[48;5;{0}m {1,2} `e[0m" -f $_, $_) }; Write-Host
# 256-color test
0..255 | ForEach-Object { Write-Host -NoNewline ("`e[48;5;{0}m `e[0m" -f $_) }; Write-Host
# True color (24-bit) test
0..76 | ForEach-Object {
$i = $_
$r = 255 - [int]($i * 255 / 76)
$g = [int]($i * 510 / 76); if ($g -gt 255) { $g = 510 - $g }
$b = [int]($i * 255 / 76)
Write-Host -NoNewline ("`e[48;2;{0};{1};{2}m `e[0m" -f $r, $g, $b)
}
Write-Host
```
Smooth color strips on all three confirms Windows Terminal supports full truecolor out of the box.
### Summary of what you get from each piece
| Result | Requires |
|--------|----------|
| A dark, pleasant background and nice base colors | Windows Terminal `colorScheme` |
| `git status` showing red/green for changes | Nothing — git emits ANSI, Terminal renders it |
| `ls` showing colored directories | PowerShell 7's `$PSStyle.FileInfo` (built in) |
| File-type icons next to filenames | `eza --icons` + a Nerd Font |
| Syntax coloring + ghost text as you type | PSReadLine (built into PowerShell 7) |
| `~\projects\demo main 3.13.2` prompt | Starship + Nerd Font |
---
## Part 5 — Optional Enhancements
### Modern CLI replacements
```powershell
winget install -e --id eza-community.eza
winget install -e --id sharkdp.bat
winget install -e --id BurntSushi.ripgrep.MSVC
winget install -e --id sharkdp.fd
winget install -e --id junegunn.fzf
winget install -e --id ajeetdsouza.zoxide
winget install -e --id direnv.direnv
```
Add to `$PROFILE`:
```powershell
# Modern replacements
function Get-ChildItemEza { eza --group-directories-first --icons @args }
function Get-ChildItemLong { eza -lah --group-directories-first --git --icons @args }
function Get-ChildItemTree { eza --tree --level=3 --git-ignore --icons @args }
Set-Alias -Name ls -Value Get-ChildItemEza -Force -Option AllScope
Set-Alias -Name ll -Value Get-ChildItemLong
Set-Alias -Name tree -Value Get-ChildItemTree
Set-Alias -Name cat -Value bat -Option AllScope
# zoxide (smarter cd — learns your most-visited dirs)
Invoke-Expression (& { (zoxide init powershell | Out-String) })
Set-Alias -Name cd -Value z -Option AllScope
# fzf integration (Ctrl+R history, Ctrl+T file picker)
Import-Module PSFzf -ErrorAction SilentlyContinue
Set-PsFzfOption -PSReadlineChordProvider 'Ctrl+t' -PSReadlineChordReverseHistory 'Ctrl+r'
```
`PSFzf` is the PowerShell binding for fzf (it doesn't come with fzf itself):
```powershell
Install-Module -Name PSFzf -Scope CurrentUser -Force
```
After this, `Ctrl+R` becomes a fuzzy-searchable command history and `z proj` jumps to the most-used directory matching "proj."
### direnv — auto-activate per-project environments
`direnv` was installed above. Hook it into PowerShell by adding to `$PROFILE`:
```powershell
Invoke-Expression "$(direnv hook pwsh)"
```
direnv reads an `.envrc` file in a project directory and loads it whenever you `cd` in, then unloads it when you leave — so each project gets its own environment (a Python virtualenv, toolchain env vars, a project-local `PATH`) with no manual activation. After creating an `.envrc`, run `direnv allow` once to trust it.
> [!note] On Windows, `.envrc` is written in bash
> direnv evaluates `.envrc` with **bash** and applies the result to PowerShell, so the file uses bash syntax (not PowerShell) and needs Git for Windows (Git Bash) or MSYS2 on `PATH`. Forward slashes in paths are fine.
The contents of `.envrc` are language-specific. Each language setup guide has a ready-to-use example: [[Python_Development_Windows_Native_Setup]], [[Go_Development_Windows_Native_Setup]], [[Rust_Development_Windows_Native_Setup]], [[Ruby_Development_Windows_Native_Setup]], and [[C_Development_Windows_Native_Setup]].
---
## Part 6 — Visual Studio Code
### Install
```powershell
winget install -e --id Microsoft.VisualStudioCode
```
Native ARM64 and x64 System Installers both ship. The installer adds `code` to the PATH; open a new PowerShell window and:
```powershell
code .
code myfile.py
code -d old.py new.py
```
### Essential general-purpose extensions
```powershell
# Better TOML (for editing pyproject.toml, Cargo.toml, starship.toml)
code --install-extension tamasfe.even-better-toml
# YAML (for GitHub Actions, docker-compose, Kubernetes)
code --install-extension redhat.vscode-yaml
# GitLens — richer git integration than the built-in
code --install-extension eamodio.gitlens
# EditorConfig — respects .editorconfig files in projects
code --install-extension editorconfig.editorconfig
# PowerShell — syntax + debugger for .ps1 scripts (you'll write a few)
code --install-extension ms-vscode.powershell
```
### Configure VS Code — `settings.json`
On Windows, VS Code stores user settings at:
```
%APPDATA%\Code\User\settings.json
```
Open it from inside VS Code via `Ctrl+Shift+P` → "Preferences: Open User Settings (JSON)". Paste in the [[_resources/configs/vscode-settings.json|companion VS Code settings]], or use this as a starting point:
```jsonc
{
// ── Editor appearance ─────────────────────────────────────
"editor.fontFamily": "'MesloLGM Nerd Font Mono', 'Cascadia Code', Consolas, monospace",
"editor.fontSize": 13,
"editor.fontLigatures": false,
"editor.lineNumbers": "on",
"editor.renderWhitespace": "boundary",
"editor.rulers": [100],
"editor.bracketPairColorization.enabled": true,
"editor.guides.bracketPairs": "active",
"editor.minimap.enabled": false,
"editor.cursorBlinking": "solid",
// ── Editor behavior ───────────────────────────────────────
"editor.formatOnSave": true,
"editor.tabSize": 4,
"editor.insertSpaces": true,
"files.trimTrailingWhitespace": true,
"files.insertFinalNewline": true,
"files.trimFinalNewlines": true,
"files.eol": "\n", // LF in repos, regardless of host
// ── Terminal (integrated) ─────────────────────────────────
"terminal.integrated.defaultProfile.windows": "PowerShell",
"terminal.integrated.profiles.windows": {
"PowerShell": {
"source": "PowerShell",
"icon": "terminal-powershell"
}
},
"terminal.integrated.fontFamily": "'MesloLGM Nerd Font Mono'",
"terminal.integrated.fontSize": 13,
"terminal.integrated.cursorBlinking": false,
"terminal.integrated.cursorStyle": "block",
"terminal.integrated.inheritEnv": true,
// ── Files & search ────────────────────────────────────────
"files.exclude": {
"**/.git": false
},
"search.exclude": {
"**/node_modules": true,
"**/dist": true,
"**/build": true,
"**/target": true,
"**/.venv": true
},
// ── Git ───────────────────────────────────────────────────
"git.autofetch": true,
"git.confirmSync": false,
"git.enableSmartCommit": true,
"git.suggestSmartCommit": false,
// ── Workbench & theme ─────────────────────────────────────
"workbench.colorTheme": "Default Dark Modern",
"workbench.iconTheme": "vs-seti",
"workbench.startupEditor": "none",
"workbench.editor.enablePreview": false,
// ── Telemetry ─────────────────────────────────────────────
"telemetry.telemetryLevel": "off",
// ── AI: disable built-in AI features ──────────────────────
// This disables Copilot prompts and any built-in AI so Claude Code
// is the only AI surface. See Part 7 for the rationale.
"chat.disableAIFeatures": true
}
```
### Why each block matters
> [!info] Font matching
> Using the same **MesloLGM Nerd Font Mono** as Windows Terminal means the integrated terminal inside VS Code looks identical to your standalone Terminal windows. The fallback chain (`Cascadia Code`, then `Consolas`) covers the case where the Nerd Font isn't found.
> [!info] `terminal.integrated.defaultProfile.windows: PowerShell`
> This is the Windows equivalent of the Mac config's `...osx: zsh` and the Linux config's `...linux: bash`. "PowerShell" (capital P) is VS Code's name for PowerShell 7 (`pwsh`); the older Windows PowerShell 5.1 appears as "Windows PowerShell" — make sure to pick the right one.
> [!info] `files.eol: "\n"`
> Forces LF line endings on save, matching the Git `core.autocrlf=input` setting. Together they keep CRLF out of your repos even when collaborators use Mac/Linux.
> [!info] Language-specific settings go in per-language guides
> `settings.json` supports language-scoped blocks like `"[python]": { ... }` that only apply to that language's files. Each language guide adds its own block to this file. They don't conflict.
---
## Part 7 — Claude Code as the Only AI (Terminal + VS Code)
> [!important] AI assistance is entirely optional
> **Everything in Parts 1–6 stands on its own.** Windows Terminal, PowerShell 7, Starship, Git, GitHub CLI, VS Code with language extensions, linters, formatters, and debuggers form a complete professional development environment. You can stop after Part 6 and have a fully functional setup. Skip this part entirely if you don't want an AI in your workflow, or come back to it later.
> [!note] If you use a different AI tool
> This guide configures Claude Code specifically. **The general principle — install your AI of choice, configure VS Code so it doesn't fight other AI tools — still applies, but the specific commands differ.** Quick pointers for the major alternatives:
>
> - **GitHub Copilot**: Install via the `github.copilot` and `github.copilot-chat` VS Code extensions. Sign in through VS Code's GitHub account integration. **Remove `"chat.disableAIFeatures": true` from settings.json** — Copilot uses VS Code's built-in chat UI that this setting hides.
> - **Cursor**: A separate editor (a fork of VS Code). Native ARM64 + x64 Windows builds available at cursor.com. Your VS Code extension list and settings.json mostly port over.
> - **Continue**: Open-source, multi-provider. Install the `continue.continue` VS Code extension and configure your model provider (Anthropic API, OpenAI, local Ollama, etc.).
> - **Cline**: Install the `saoudrizwan.claude-dev` VS Code extension; bring your own API key.
> - **Aider**: Terminal-based, like Claude Code. Install with `uv tool install aider-chat` (after the Python guide) and configure with your provider's API key.
>
> Whichever you pick, the "uninstall competing extensions" advice still applies: pick one AI surface and remove the others.
This section sets up Claude Code so it's your single AI surface across both the terminal and the editor.
### What you're setting up
| Surface | How Claude Code appears |
|---------|-------------------------|
| **Windows Terminal** | Run `claude` inside any project directory → interactive terminal agent with file edits, shell commands, git operations |
| **VS Code** | Spark icon in Activity Bar → sidebar chat with inline diffs, `@`-file mentions, plan mode, accept/reject buttons |
Both surfaces share the **same auth**, **same `%USERPROFILE%\.claude\` config**, and **same `CLAUDE.md` project files**.
### Prerequisites
- An **Anthropic account** with access to Claude Code. Claude Pro or Claude Max is the straightforward path; API credits via Anthropic Console also work.
- **VS Code** (covered in Part 6).
- **Windows Terminal + PowerShell 7** (covered in Parts 1–2).
> [!warning] The free Claude.ai plan does not include Claude Code
> Any paid Claude subscription (Pro, Max, Teams, Enterprise) does, and so does Anthropic Console with API credits.
### Install Claude Code
```powershell
winget install -e --id Anthropic.Claude.Code
```
This is the recommended path — winget always pulls the current release and the installer detects your architecture (ARM64 or x64).
> [!warning] Make sure your version is ≥ 2.1.41 on ARM64
> The native Windows ARM64 binary for Claude Code shipped in **v2.1.41 (Feb 2026)**. Older installs error with "Platform win32-arm64 not found in manifest." winget always pulls the current release, so this is only an issue if you have an old install lingering — fix with `winget upgrade --id Anthropic.Claude.Code` or `winget install --id Anthropic.Claude.Code --force`.
Open a new PowerShell window and verify:
```powershell
Get-Command claude
claude --version
```
> [!info] Why not npm?
> The npm method (`npm install -g @anthropic-ai/claude-code`) still works but is deprecated. The native install auto-updates silently in the background, which is what you want for an AI tool that improves weekly.
### First-run authentication
From Windows Terminal, in any project directory:
```powershell
cd $HOME\projects
claude
```
On first launch Claude Code opens a browser window for OAuth login. Sign in with the same Anthropic account as your Claude Pro/Max subscription. The token is saved to `%USERPROFILE%\.claude\` and reused across both Windows Terminal and VS Code.
### Using Claude Code in Windows Terminal
Inside any project, start a session with `claude`. Useful built-in commands:
```
/help List all slash commands
/init Generate a CLAUDE.md for this project (do this first!)
/clear Clear conversation context
/rewind Restore to a checkpoint (undo Claude's changes)
/plugins Browse and install plugins
/terminal-setup Auto-configure Shift+Enter for multi-line prompts
/exit Leave the session
```
Claude can read and edit files, run shell commands (with your permission per-command), use `git`, and manage its context automatically. Every code change is checkpointed — press **Esc twice** or run `/rewind` to undo.
> [!tip] Make CLAUDE.md your first step in any project
> `/init` scans your project and writes a `CLAUDE.md` with project structure, conventions, and commonly-used commands. Claude loads this file at the start of every session. Commit it to git so it's shared with anyone else working on the repo.
### Installing the VS Code extension
**Path A — From inside VS Code (recommended):**
1. `Ctrl+Shift+X` to open Extensions
2. Search **"Claude Code"** — install the one published by **Anthropic** (avoid look-alikes)
3. Reload VS Code if prompted
**Path B — From PowerShell:**
```powershell
code --install-extension anthropic.claude-code
```
Or just run `claude` inside a VS Code integrated terminal once — Claude Code auto-installs its extension when it detects a VS Code environment.
### First use in VS Code
After install, you'll see new UI elements: a **Spark icon** in the Activity Bar (left sidebar), a **Spark icon** in the top-right editor toolbar, and **"✱ Claude Code"** in the status bar. Click any of them; first launch reuses the same Anthropic auth as the CLI.
Once signed in:
- Type into the prompt box at the bottom of the sidebar
- `@filename` to attach specific files as context
- Highlight code → right-click → "Add to Claude Code context"
- Changes appear as **inline diffs** — accept per-hunk or per-file
### Making Claude Code the only AI
**1. Disable VS Code's built-in AI** (done in Part 6 via `settings.json`):
```json
"chat.disableAIFeatures": true
```
**2. Don't install (or uninstall) competing extensions:**
```powershell
code --uninstall-extension github.copilot
code --uninstall-extension github.copilot-chat
code --uninstall-extension continue.continue
code --uninstall-extension saoudrizwan.claude-dev
code --uninstall-extension sourcegraph.cody-ai
```
**3. In the terminal, don't wire in competing CLIs.** Claude Code is sufficient — avoid installing Aider, Gemini CLI, or similar alongside it if the goal is a single AI.
### Terminal vs VS Code — when to use which
| Use **Windows Terminal + `claude`** when | Use **VS Code extension** when |
|------------------------------------------|--------------------------------|
| Exploring a new repo you haven't opened yet | Reviewing changes with inline diffs |
| Bulk refactors spanning many files | Editing a specific function with tight feedback |
| Running tests/builds interactively | Using `@mentions` to pull specific files into context |
| SSH'd into a remote machine | You want to pair with Claude while you edit |
They aren't mutually exclusive — it's common to have `claude` running in a Terminal pane while VS Code is open on the same project.
### Useful extras
**Multi-line prompts in VS Code's integrated terminal** — run this once inside Claude Code:
```
/terminal-setup
```
**Checkpoints** — Claude automatically checkpoints before each change. Undo with `Esc` twice (in terminal) or `/rewind`. Checkpoints only cover Claude's edits — keep using git commits for the real backup.
---
## Troubleshooting
> [!warning] Glyphs show as boxes or `?` in the prompt
> Your font isn't a Nerd Font. Reinstall it (Part 1), then in Windows Terminal Settings → Profile → Appearance, set Font face to "MesloLGM Nerd Font" (or "MesloLGM Nerd Font Mono"). Apply, restart Terminal.
> [!warning] Starship prompt didn't appear after editing `$PROFILE`
> Run `. $PROFILE` to reload, or open a new tab. If it still doesn't appear, run `pwsh -NoProfile` to confirm the profile is the issue, then `code $PROFILE` and look for syntax errors near the `Invoke-Expression (&starship init powershell)` line.
> [!warning] `command not found` for a tool right after installing
> winget adds tools to your PATH, but the current window may have a stale environment. Open a new Windows Terminal window or run `refreshenv` (if you have Chocolatey installed) or close and reopen Terminal.
> [!warning] `claude` not found after install on ARM64
> Confirm `winget upgrade --id Anthropic.Claude.Code` shows a version ≥ 2.1.41. If you previously installed via npm, the npm shim may shadow the native binary — uninstall the npm version: `npm uninstall -g @anthropic-ai/claude-code`.
> [!warning] `git push` asks for username/password every time
> Confirm `git config --global credential.helper` prints `manager`. If it's empty, set it: `git config --global credential.helper manager`. If GCM keeps re-prompting, run `git credential-manager configure` and `git credential-manager diagnose` for guidance.
> [!warning] CRLF / LF chaos when opening a repo from a Mac/Linux collaborator
> Confirm `git config --global core.autocrlf` is `input` (not `true`) and that your VS Code `files.eol` is `"\n"`. Add a `.gitattributes` to the repo (`* text=auto eol=lf`) for belt-and-suspenders.
> [!warning] Starship language version not showing
> Starship only shows a language module when it detects a matching project — you need the relevant file (e.g. `pyproject.toml`, `go.mod`, `Cargo.toml`) in the directory. This is intentional, to avoid clutter.
> [!warning] PowerShell 7 settings don't apply (changes in `$PROFILE` ignored)
> You may have edited the Windows PowerShell 5.1 profile by mistake. Confirm which file you're editing: run `$PROFILE` in PowerShell 7 — the path should contain `\PowerShell\` (not `\WindowsPowerShell\`).
> [!warning] `Invoke-Expression (&starship init powershell)` errors with "starship: command not recognized"
> winget didn't update PATH for the current window. Open a new Terminal tab and try again. If still missing, manually add `C:\Program Files\starship\bin` to your user PATH via Windows Settings → System → About → Advanced system settings → Environment Variables.
---
## Summary — the complete install sequence
> [!warning] This is a checklist, not a script
> The block below is **not a script you can save and run.** It's a numbered sequence of commands to **copy and paste into PowerShell one block at a time**, in order. Several steps depend on the previous one having finished, and three steps require you to **manually edit files** before continuing:
>
> - **Step 10** asks you to paste the recommended **Windows Terminal settings** into `settings.json`
> - **Step 10** also asks you to paste the recommended **Starship config** into `~\.config\starship.toml`
> - **Step 10** also asks you to paste the recommended **VS Code settings** into `%APPDATA%\Code\User\settings.json`
> - **Step 10** also asks you to paste the recommended **PowerShell `$PROFILE`** into your profile file
>
> Two later steps (11 — `gh auth login`; 12 — `claude` first run) **open a browser window** and require you to complete OAuth login interactively before continuing.
```powershell
# 1. Confirm prerequisites
$env:PROCESSOR_ARCHITECTURE # AMD64 or ARM64
winget --version
# 2. Core terminal + shell
winget install -e --id Microsoft.WindowsTerminal
winget install -e --id Microsoft.PowerShell
# 3. Git + GitHub CLI
winget install -e --id Git.Git
winget install -e --id GitHub.cli
# 4. Editor + AI
winget install -e --id Microsoft.VisualStudioCode
winget install -e --id Anthropic.Claude.Code
# 5. Prompt + modern CLI replacements
winget install -e --id Starship.Starship
winget install -e --id eza-community.eza
winget install -e --id sharkdp.bat
winget install -e --id BurntSushi.ripgrep.MSVC
winget install -e --id sharkdp.fd
winget install -e --id junegunn.fzf
winget install -e --id ajeetdsouza.zoxide
winget install -e --id direnv.direnv
winget install -e --id 7zip.7zip
# 6. PSReadLine + PSFzf (PowerShell modules)
Install-Module -Name PSReadLine -AllowPrerelease -Scope CurrentUser -Force -SkipPublisherCheck
Install-Module -Name PSFzf -Scope CurrentUser -Force
# 7. Nerd Font — manual:
# Download https://github.com/ryanoasis/nerd-fonts/releases/latest/download/Meslo.zip
# Extract; select all .ttf; right-click → "Install for all users"
# 8. Git config (REPLACE name/email)
git config --global user.name "Your Name"
git config --global user.email "
[email protected]"
git config --global init.defaultBranch main
git config --global pull.rebase false
git config --global push.autoSetupRemote true
git config --global color.ui auto
git config --global core.editor "code --wait"
git config --global core.autocrlf input
git config --global credential.helper manager
git config --global fetch.prune true
git config --global commit.verbose true
git config --global diff.algorithm histogram
git config --global rerere.enabled true
git config --global help.autocorrect 20
# 9. SSH key for GitHub
Add-WindowsCapability -Online -Name OpenSSH.Client~~~~0.0.1.0 # if ssh missing
ssh-keygen -t ed25519 -C "
[email protected]"
Get-Service ssh-agent | Set-Service -StartupType Automatic
Start-Service ssh-agent
ssh-add $HOME\.ssh\id_ed25519
Get-Content $HOME\.ssh\id_ed25519.pub | Set-Clipboard
# Paste the key at https://github.com/settings/keys, then:
ssh -T
[email protected]
# 10. Paste the Windows Terminal settings, Starship config,
# VS Code settings, and PowerShell $PROFILE into place
# (see Parts 1, 2, and 6 for the recommended contents)
mkdir $HOME\.config -ErrorAction SilentlyContinue
if (-not (Test-Path $PROFILE)) { New-Item -Type File -Path $PROFILE -Force }
# 11. General-purpose VS Code extensions
code --install-extension tamasfe.even-better-toml
code --install-extension redhat.vscode-yaml
code --install-extension eamodio.gitlens
code --install-extension editorconfig.editorconfig
code --install-extension ms-vscode.powershell
code --install-extension anthropic.claude-code
# 12. Authenticate GitHub CLI (interactive — HTTPS, browser login)
gh auth login
gh auth setup-git
# 13. First launch of Claude Code (interactive OAuth in browser)
# Run `claude` in Windows Terminal — a browser window opens for login.
```
Open a fresh Windows Terminal tab, and you're done with the general setup. Pick a language guide to continue:
- [[Python_Development_Windows_Native_Setup]]
- [[C_Development_Windows_Native_Setup]]
- [[Ruby_Development_Windows_Native_Setup]]
- [[Go_Development_Windows_Native_Setup]]
- [[Rust_Development_Windows_Native_Setup]]
---
## Related notes
**Same setup on other platforms:**
- [[General_Development_Mac_Tahoe_Setup]] — the Apple Silicon counterpart
- [[General_Development_Ubuntu_Setup]] — the Linux counterpart
**The other Windows path:**
- [[WSL2 Windows Development Setup]] — Linux-inside-Windows alternative
**Language-specific setup (build on this general guide):**
- [[Python_Development_Windows_Native_Setup]]
- [[C_Development_Windows_Native_Setup]]
- [[Ruby_Development_Windows_Native_Setup]]
- [[Go_Development_Windows_Native_Setup]]
- [[Rust_Development_Windows_Native_Setup]]
**Topic references:**
- [Microsoft Learn — winget](https://learn.microsoft.com/en-us/windows/package-manager/winget/)
- [Microsoft Learn — Install PowerShell on Windows](https://learn.microsoft.com/en-us/powershell/scripting/install/install-powershell-on-windows)
- [Microsoft Learn — Install Windows Terminal](https://learn.microsoft.com/en-us/windows/terminal/install)
- [Microsoft Learn — Custom Prompt Setup (Nerd Fonts)](https://learn.microsoft.com/en-us/windows/terminal/tutorials/custom-prompt-setup)
- [PSReadLine on GitHub](https://github.com/PowerShell/PSReadLine)
- [Starship](https://starship.rs/)
- [Git Cheat Sheet](https://git-scm.com/cheat-sheet)
- [Claude Code Tips](https://code.claude.com/docs/en/best-practices)
- [CLAUDE.md Templates](https://code.claude.com/docs/en/memory)