Homebrew: Still the Package Manager, No Competition

Homebrew 4.3 dropped the JSON API for formula resolution and now resolves dependencies locally, cutting install times by roughly 40% on a warm cache. If you're still on 4.1 or earlier, upgrade before doing anything else.

The `brew bundle` workflow is the right way to handle macOS tooling in a team environment. Commit a `Brewfile` to your dotfiles repo and every new machine setup becomes a single command. We maintain separate Brewfiles for base tooling and optional GUI apps to keep CI bootstrap times under two minutes.

# Install Homebrew
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Upgrade if already installed
brew update && brew upgrade

# Dump current install state
brew bundle dump --file=~/dotfiles/Brewfile

# Bootstrap a new machine
brew bundle install --file=~/dotfiles/Brewfile

iTerm2 vs Ghostty: Terminal Emulator Showdown

iTerm2 3.5 remains the default recommendation for engineers who rely on tmux integration, shell integration scripts, and the Python API for automation. The tmux integration mode (`tmux -CC`) maps iTerm2 panes directly to tmux windows, which is useful when SSH'd into a remote box and you want native macOS window management.

Ghostty 1.1, written in Zig, launched as a serious alternative in late 2024 and we've been running it as a daily driver since January 2025. GPU rendering makes scrollback through 100k lines of log output noticeably faster than iTerm2. It lacks the Python API and some of the shell integration depth, but for engineers who live in tmux anyway, those gaps don't matter. Config is a plain text file at `~/.config/ghostty/config`.

Our recommendation: use Ghostty if you're tmux-native. Use iTerm2 if you need the Python scripting API or the tmux integration mode for remote sessions.

# iTerm2 via Homebrew
brew install --cask iterm2

# Ghostty via Homebrew
brew install --cask ghostty

# Minimal Ghostty config
cat > ~/.config/ghostty/config << 'EOF'
font-family = "JetBrains Mono"
font-size = 13
theme = "GruvboxDark"
window-padding-x = 8
window-padding-y = 8
cursor-style = bar
EOF

Warp: The Terminal for Teams Who Write Scripts Together

Warp 2.0 introduced shared workflows, which are essentially versioned shell scripts with parameter prompts stored in Warp's cloud. If your team has 3+ engineers who share common deployment or diagnostic commands, Warp workflows reduce the overhead of maintaining a wiki page full of copy-paste commands.

The AI command completion (Warp AI) runs locally inferred suggestions for common patterns and calls the API for complex queries. In our testing, it correctly completed a multi-step `kubectl` rollout command roughly 70% of the time without needing the API call. For privacy-sensitive environments, Warp supports a local-only mode that disables all telemetry and cloud features.

Warp is an Electron-ish app at its core, and memory usage shows it - around 400MB baseline versus Ghostty's 80MB. That tradeoff is real. For solo developers, Ghostty or iTerm2 wins on resources. For teams sharing operational runbooks, Warp's workflow sharing is genuinely useful.

brew install --cask warp
// advertisement

Raycast: Alfred Is Retired, Long Live Raycast

Raycast 1.80 replaced Alfred in our workflow in 2023 and we haven't looked back. The extension ecosystem covers everything Alfred did via workflows but with a typed API and proper sandboxing. Extensions are written in React with a published TypeScript SDK, which means any frontend engineer on your team can build internal tooling extensions without learning AppleScript.

For DevOps work, the most-used Raycast extensions on our machines are: the Docker extension for container management without opening a GUI, the GitHub extension for PR review and issue tracking from the launcher, and the SSH Hosts extension that reads `~/.ssh/config` and opens iTerm2 or Ghostty tabs directly.

Raycast Pro at $96/year adds AI features and sync. The free tier is sufficient for most DevOps workflows. The Raycast Store at raycast.com/store has over 1,400 extensions as of Q1 2026.

brew install --cask raycast

# After install, import settings from backup
# Raycast -> Preferences -> Advanced -> Import/Export

Visual Studio Code and Neovim: Use Both

VS Code 1.95 on Apple Silicon runs noticeably faster than on Intel. The Remote - SSH extension is the primary reason sysadmins keep VS Code installed - editing files on remote servers with full language server support (LSP), linting, and IntelliSense through an SSH tunnel is difficult to replicate cleanly in a pure terminal workflow.

Neovim 0.10 with `lazy.nvim` as a plugin manager is the right choice for terminal-first work. The `LazyVim` distribution bundles a sane default config with LSP support via `nvim-lspconfig`, Telescope for fuzzy finding, and Treesitter for syntax highlighting. Getting from zero to a productive Neovim setup used to take days; LazyVim gets you there in under an hour.

We use VS Code for remote SSH editing and any project involving a JavaScript/TypeScript frontend. We use Neovim for everything in the terminal: config files, quick edits over SSH, scripting. The two don't conflict.

# VS Code
brew install --cask visual-studio-code

# Neovim
brew install neovim

# LazyVim bootstrap
git clone https://github.com/LazyVim/starter ~/.config/nvim
rm -rf ~/.config/nvim/.git
nvim  # triggers plugin install on first launch

TablePlus: Database GUI That Doesn't Get in the Way

TablePlus 6.1 supports PostgreSQL, MySQL, SQLite, Redis, MongoDB, and ClickHouse from a single app. The connection manager reads from a local encrypted store, not a cloud account, which matters in environments with strict data handling requirements.

The killer feature for developers is the safe mode toggle. Safe mode blocks destructive queries (DELETE without WHERE, DROP without confirmation) until you explicitly disable it per session. We've stopped at least three accidental production wipes across our team since enabling it as the default.

TablePlus costs $99 for a perpetual license with one year of updates. After that year, the version you have keeps working - no subscription required. For engineers who've used DBeaver or DataGrip, the native macOS UI and speed difference is apparent within the first session.

brew install --cask tableplus
// advertisement

Docker Desktop vs OrbStack: Memory Tells the Story

OrbStack 1.7 uses 200-300MB of RAM with a typical multi-container dev stack running. Docker Desktop 4.30 on the same stack uses 1.2-1.8GB. On a MacBook with 16GB RAM, that gap matters when you also have a JVM-based IDE, a browser with 20 tabs, and a few terminal sessions open.

OrbStack runs a lightweight Linux VM using Apple's Virtualization framework and presents a Docker-compatible socket at `/var/run/docker.sock`. All your existing `docker-compose` files and `docker` CLI commands work without modification. `kubectl` contexts for local Kubernetes clusters work through OrbStack's built-in k8s node as well.

Docker Desktop is still the safer choice for teams where some engineers are on Windows or Linux, because the tooling and troubleshooting docs are identical across platforms. For a macOS-only team, OrbStack is the right call.

# OrbStack
brew install --cask orbstack

# Verify Docker socket
docker context ls
# Should show orbstack as active context

# Run a quick test
docker run --rm hello-world

DevOps Automation: AI Tools and Local Agents

AI-assisted DevOps moved from experimental to practical in 2025. Tools like taskbotshub.ai focus specifically on automating repetitive DevOps workflows - incident triage, log pattern detection, and runbook execution - without requiring you to build custom LLM integrations from scratch. For teams running on-call rotations with dozens of alert types, the ability to hook an AI agent into PagerDuty and have it execute the first three diagnostic steps automatically is worth evaluating against the cost of engineering time.

For local AI inference on Apple Silicon, Ollama 0.3 runs Llama 3.1 8B at roughly 35 tokens/second on an M3 Pro. That's fast enough for code completion assistance and documentation queries without sending data to an external API. Pair it with the `Continue` VS Code extension for inline AI completions that stay on your machine.

# Ollama install
brew install ollama

# Start the service
brew services start ollama

# Pull and run Llama 3.1 8B
ollama pull llama3.1:8b
ollama run llama3.1:8b

# API endpoint for Continue extension
# http://localhost:11434/api/generate

Proxyman: HTTP Debugging Without Burp Suite Overhead

Proxyman 5.4 intercepts HTTP and HTTPS traffic from any process on macOS, including CLI tools, without requiring per-app proxy configuration. The automatic certificate installation and system proxy setup takes about 30 seconds. For debugging API calls from a Go binary or diagnosing why a Python script's HTTPS requests are failing, Proxyman is significantly faster to set up than configuring Charles Proxy or spinning up mitmproxy.

The breakpoint feature lets you intercept a request, modify the body or headers, and resume it - useful for testing API edge cases without writing test fixtures. Proxyman is free for basic use; the Pro license at $89 adds scripting via JavaScript for automated request/response modification.

For pure CLI work, `mitmproxy` via Homebrew is the correct choice. Proxyman is for when you need a GUI to see the full request flow quickly.

brew install --cask proxyman

# CLI alternative
brew install mitmproxy

# mitmproxy with web UI
mitmweb --port 8080
// advertisement

Project Naming and Domain Registration in the Development Workflow

When spinning up a new internal tool, microservice, or side project, naming is a real time sink that most engineering workflows don't account for. Services like nicename.me solve the specific problem of finding a name with an available domain in a single step rather than running `whois` queries in a loop against a list of candidates you manually generated.

For a Brewfile or dotfiles repo this doesn't apply. But for anything that will have a public endpoint - a developer tool, an open source project, a SaaS side project - having the name and domain resolved before you start wires up GitHub, DNS, and branding from the beginning instead of renaming things six weeks in. We've found this particularly useful when launching developer-facing tools where the `.io` or `.dev` TLD availability is critical.

# Quick whois check from terminal if you already have a name
whois yourprojectname.dev | grep 'No match\|Creation Date'

# Or use the dig approach to check nameserver delegation
dig yourprojectname.dev NS +short

Supporting Tools Worth the Brew Install

A few tools that didn't warrant full sections but belong in every developer's `Brewfile` on macOS in 2025.

`Rectangle Pro` ($9.99) handles window management with keyboard shortcuts. The free Rectangle is fine, but Pro adds window history and per-app rules. For engineers switching between a MacBook screen and external monitors, the snap-to-zone feature with modifier keys is the fastest window management approach available.

`Stats` (free, open source) puts CPU, memory, network, and disk IO into the menu bar as compact graphs. More useful than Activity Monitor for quick checks. Pulls data from the same APIs as `top` and `vm_stat`.

`Secretive` (free, open source) stores SSH keys in the Secure Enclave rather than on disk. Keys generated in Secretive cannot be exported. For engineers with access to production systems, this meaningfully reduces the blast radius of a stolen laptop.

`Fork` ($59.99 perpetual) is the best GUI Git client on macOS if you need one. Faster than GitKraken, more capable than GitHub Desktop. The interactive rebase view alone justifies the price for engineers who rebase frequently.

# Add to Brewfile
brew "stats"
brew "--cask" "rectangle-pro"
brew "--cask" "secretive"
brew "--cask" "fork"

# Or direct install
brew install --cask rectangle-pro secretive fork
brew install stats