When I reset my MacBook, I did not want to install every tool I had ever heard of.
I wanted a setup that was clean, reproducible, and useful for the kind of work I care about: DevOps, Platform Engineering, infrastructure, containers, Kubernetes, automation, and cloud-native systems.
The goal was simple:
Install the 20% of tools that support 80% of the work.
This post walks through the setup I built and why each tool made the cut.
The Philosophy
A developer machine can easily become cluttered.
You install one tool for one tutorial, another tool for one job interview, another tool for one side project, and before long your laptop becomes a museum of forgotten experiments.
I wanted something different.
This setup had to be:
- Reproducible on another laptop
- Beginner-friendly
- Minimal, but not underpowered
- Useful for real DevOps and Platform Engineering workflows
- Easy to document and improve over time
The result is a public setup repo built around a Brewfile.
A Brewfile is a simple file that tells Homebrew which tools to install. Instead of manually installing every tool one by one, you can run one command and recreate the setup.
The Core Idea: Reproducibility First
The first tool I installed was Homebrew.
Homebrew is the package manager that makes the rest of the setup easier. Once Homebrew is installed, most tools can be installed, checked, and reproduced using a Brewfile.
The basic flow is:
brew bundle
That command reads the Brewfile in the current directory and installs what is missing.
You can also run it explicitly:
brew bundle --file Brewfile
To check whether everything is already installed:
brew bundle check --file Brewfile
To install only missing tools:
brew bundle install --file Brewfile
This is what makes the setup portable. A new laptop does not have to become a manual checklist. It can become a repeatable recipe.
Stage 1: Git and GitHub
The first real development tool is Git.
brew install git
Git is the foundation for code, infrastructure, scripts, documentation, and almost every collaborative engineering workflow.
After installing Git, I configured my identity:
git config --global user.name "Your Name"
git config --global user.email "your-email@example.com"
git config --global init.defaultBranch main
I also set up SSH authentication for GitHub.
ssh-keygen -t ed25519 -C "your-email@example.com"
ssh-add --apple-use-keychain ~/.ssh/id_ed25519
pbcopy < ~/.ssh/id_ed25519.pub
Then I added the public key to GitHub and tested it:
ssh -T git@github.com
This makes GitHub access smoother because I can clone, push, and pull without typing passwords or handling tokens manually.
Stage 2: Terminal Setup
I kept the terminal setup simple. No heavy framework. No overloaded prompt. No dashboard pretending to be a shell.
The terminal stack is:
brew install --cask font-jetbrains-mono-nerd-font
brew install starship
The font gives the terminal a clean developer feel, and Starship gives a useful prompt.
My prompt shows:
- An arrow
- The current directory
- The Git branch when I am inside a repository
Example:
➜ minimal-devops-mac-setup git:(main)
That is enough context without visual noise.
Stage 3: VS Code
VS Code is the editor for this setup.
brew install --cask visual-studio-code
I kept the editor clean:
- No minimap
- Format on save
- JetBrains Mono font
- Integrated terminal using zsh
- A small set of extensions for DevOps work
The extensions I installed are:
redhat.vscode-yaml
github.vscode-github-actions
hashicorp.terraform
ms-kubernetes-tools.vscode-kubernetes-tools
timonwong.shellcheck
editorconfig.editorconfig
ms-azuretools.vscode-docker
esbenp.prettier-vscode
ms-vscode-remote.remote-ssh
ms-python.python
This gives support for YAML, GitHub Actions, Terraform, Kubernetes, shell scripts, Docker, Python, and remote SSH work. Not a huge extension list — just enough for the kind of work this machine is meant to support.
Stage 4: Everyday CLI Tools
Before installing the bigger platform tools, I added small command-line tools that make daily work easier.
jq — reading and filtering JSON.
brew install jq
echo '{"name":"devops","role":"platform"}' | jq '.role'
yq — like jq, but for YAML.
brew install yq
printf 'name: devops\nrole: platform\n' | yq '.role'
ripgrep — fast search.
brew install ripgrep
rg "deployment"
fd — a friendlier file finder.
brew install fd
fd README
tree — shows folder structure clearly.
brew install tree
tree -L 2
ShellCheck — checks shell scripts for common mistakes.
brew install shellcheck
This is a small tool, but it teaches a good habit early: do not trust shell scripts just because they run once.
Stage 5: Python with uv
For Python, I chose uv.
brew install uv
uv is a modern Python package and project manager. Instead of relying on the system Python, I can use uv for project-based Python workflows.
uv init
uv add requests
uv run python main.py
For existing projects:
uv sync
This keeps Python project setup cleaner and easier to reproduce.
Stage 6: Containers
For containers, I used Docker CLI, Docker Compose, and Colima.
brew install docker docker-compose colima
On macOS, Docker needs a lightweight Linux environment to run containers. Colima provides that without requiring Docker Desktop.
Start Colima:
colima start
Verify Docker:
docker version
colima status
Test with a small container:
docker run --rm hello-world
If docker compose does not work immediately, link the Compose plugin:
mkdir -p ~/.docker/cli-plugins
ln -sf /opt/homebrew/bin/docker-compose ~/.docker/cli-plugins/docker-compose
Then verify:
docker compose version
Stage 7: Kubernetes
Once containers were working, I added Kubernetes tooling.
kubectl — the main command-line tool for working with Kubernetes clusters.
brew install kubectl
kubectl version --client
kind — Kubernetes in Docker. Runs a local cluster on your laptop.
brew install kind
kind create cluster --name devops-local
kind get clusters
kubectl get nodes
Delete the cluster when you no longer need it:
kind delete cluster --name devops-local
This is great for beginners because you can practice Kubernetes without needing a cloud account.
k9s — a terminal UI for Kubernetes.
brew install k9s
k9s
It makes it easier to inspect pods, deployments, services, logs, and nodes. It does not replace kubectl, but it makes cluster exploration much easier.
Helm:
brew install helm
helm version
Beginner note: Helm is useful, but not required when you are just starting. Start with plain Kubernetes YAML, kubectl apply, and Kustomize first. Helm becomes more useful when you begin installing existing tools into a cluster, such as ingress controllers, cert-manager, or monitoring stacks.
Stage 8: Infrastructure as Code
For Infrastructure as Code, I installed Terraform.
brew tap hashicorp/tap
brew install hashicorp/tap/terraform
terraform version
Terraform is widely used in DevOps and Platform Engineering roles. It lets you define infrastructure using configuration files instead of clicking through cloud consoles manually.
I also installed terraform-docs.
brew install terraform-docs
terraform-docs version
This encourages a good habit early: document your infrastructure as you build it.
Stage 9: GitHub CLI
Since this setup is GitHub-first, I installed the GitHub CLI.
brew install gh
gh auth login
Recommended choices:
GitHub.com
SSH
Login with a web browser
Verify:
gh auth status
gh --version
The GitHub CLI makes it easier to create repositories, inspect pull requests, check GitHub Actions runs, and work with GitHub from the terminal.
The Brewfile
The most important part of this setup is not any single tool. It is the Brewfile.
The full repo is at github.com/NewerKey/minimal-devops-mac-setup. Clone it and run brew bundle to get started.
tap "hashicorp/tap"
cask "visual-studio-code"
cask "font-jetbrains-mono-nerd-font"
brew "starship"
brew "git"
brew "gh"
brew "jq"
brew "yq"
brew "ripgrep"
brew "fd"
brew "tree"
brew "shellcheck"
brew "uv"
brew "docker"
brew "docker-compose"
brew "colima"
brew "kubectl"
brew "kind"
brew "k9s"
brew "helm"
brew "hashicorp/tap/terraform"
brew "terraform-docs"
vscode "redhat.vscode-yaml"
vscode "github.vscode-github-actions"
vscode "hashicorp.terraform"
vscode "ms-kubernetes-tools.vscode-kubernetes-tools"
vscode "timonwong.shellcheck"
vscode "editorconfig.editorconfig"
vscode "ms-azuretools.vscode-docker"
vscode "esbenp.prettier-vscode"
vscode "ms-vscode-remote.remote-ssh"
vscode "ms-python.python"
To use it:
brew bundle --file Brewfile
To check it:
brew bundle check --file Brewfile
What the Brewfile Does Not Do
The Brewfile installs tools, but it does not configure everything.
You still need to set up:
- Git user identity
- SSH keys
- GitHub CLI login
- Terminal prompt config
- VS Code settings
- Cloud credentials
- Any secrets or environment variables
That is intentional. Secrets and personal credentials should not live in a public setup repo.
What I Would Add Later
This setup is not finished forever. It is just a solid version one.
Later additions could include:
- Cloud CLIs like AWS CLI, Azure CLI, or Google Cloud CLI
- OpenTofu as a Terraform alternative
- Argo CD or Flux for GitOps
- Ansible for configuration management
- Dev Containers for project-level reproducibility
- A dotfiles repo for terminal and editor configuration
But I do not want to add those before I need them. Minimal does not mean incomplete. It means intentional.
Final Thoughts
A good workstation setup should help you start working, not become the work.
This setup gives a clean base for DevOps and Platform Engineering:
- Git and GitHub
- A simple terminal
- A focused editor
- JSON and YAML tools
- Containers
- Local Kubernetes
- Terraform
- Documentation habits
- A reproducible
Brewfile
The best part is that I can rebuild it on another Mac without relying on memory. That is the real win.
Not just a configured laptop. A repeatable setup.