Build Your Own Dev Toolkit: A Practical Setup Guide

A dev toolkit is the set of tools you use every day to write, run, test and ship code: a terminal and shell, a package manager, a runtime version manager, an editor, Git, a handful of command-line utilities, containers, an API client and, increasingly, an AI coding assistant. The best toolkit is small, scripted and reproducible, so you can rebuild it on a new machine in under an hour. This guide gives you a layer-by-layer checklist and the exact commands to set it up on macOS, Linux and Windows as of October 2026.

If you are deciding between open source and paid tools for each layer, read developer toolkit: open source vs proprietary. This post is about putting a working toolkit together.

The dev toolkit checklist

Layer	What it does	Sensible default
Package manager	Installs everything else	Homebrew (macOS/Linux), winget (Windows)
Shell + terminal	Where you run commands	zsh or bash; any modern terminal (iTerm2, Ghostty, Windows Terminal)
Runtime versions	One Node/Python/Go version per project	mise
Editor	Writing and debugging code	VS Code, a JetBrains IDE, Zed or Neovim
Version control	History, branches, collaboration	Git + GitHub CLI
CLI utilities	Search, JSON, navigation	ripgrep, fd, fzf, jq
Containers	Run databases and services locally	Docker Desktop, or Colima / Podman
API client	Call and debug HTTP APIs	Bruno, Hoppscotch, curl
AI assistant	Write, explain and refactor code	One assistant integrated in your editor or terminal
Dotfiles	Make all of the above reproducible	A Git repo with your configs and install script

Pick one tool per layer. Two tools doing the same job (two version managers, two formatters) is the most common source of "works on my machine" bugs.

Step 1: Install a package manager

macOS and Linux: install Homebrew with the command from brew.sh:

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

Windows: winget ships with current Windows 10 and 11 as part of App Installer. Check it with winget --version. If you develop on Windows, also consider WSL (wsl --install), which gives you a real Linux environment where the Linux instructions below apply.

Step 2: Install the core tools in one go

On macOS or Linux with Homebrew:

brew install git gh mise ripgrep fd fzf jq

On Windows:

winget install --id Git.Git -e
winget install --id GitHub.cli -e
winget install --id jdx.mise -e
winget install --id BurntSushi.ripgrep.MSVC -e
winget install --id jqlang.jq -e

What each one is for:

• ripgrep (rg): searches a codebase for text far faster than grep, and respects .gitignore.
• fd: a simpler, faster find.
• fzf: fuzzy finder for files, command history (Ctrl+R) and Git branches.
• jq: slice and format JSON, for example curl -s https://api.github.com/repos/nodejs/node | jq .stargazers_count.
• gh: open pull requests, check CI and clone repos from the terminal.

Step 3: Manage runtime versions per project

Installing Node or Python globally breaks the moment two projects need different versions. A version manager fixes that. mise handles Node, Python, Go, Ruby, Java and many more with one tool.

Activate it in your shell (zsh shown; the docs list bash and fish):

echo 'eval "$(mise activate zsh)"' >> ~/.zshrc
exec zsh

Then pin versions inside a project:

cd my-project
mise use node@24 python@3.13

This writes a mise.toml file to the project. Commit it, and anyone who runs mise install gets the same versions. As of October 2026, Node.js 24 and 22 are the supported LTS lines and Node 20 reached end of life in March 2026, per the Node.js release page.

Step 4: Configure Git once

git config --global user.name "Your Name"
git config --global user.email "you@example.com"
git config --global init.defaultBranch main
git config --global pull.rebase true
git config --global rerere.enabled true

Create an SSH key and connect it to GitHub:

ssh-keygen -t ed25519 -C "you@example.com"
gh auth login

gh auth login walks you through signing in and can upload the SSH key for you. To sign commits with the same key (GitHub shows them as "Verified"), see GitHub's guide on SSH commit signing:

git config --global gpg.format ssh
git config --global user.signingkey ~/.ssh/id_ed25519.pub
git config --global commit.gpgsign true

Then add the public key to GitHub as a signing key (Settings > SSH and GPG keys > New SSH key > Key type: Signing Key).

Step 5: Pick an editor and keep its settings portable

Choose one main editor and learn it properly: the command palette, multi-cursor editing, go-to-definition, the integrated debugger and the test runner. Whatever you pick, keep settings out of your head:

• VS Code: turn on Settings Sync, and commit a .vscode/extensions.json with recommended extensions to each project.
• JetBrains IDEs: use Settings Sync or export settings.
• Neovim: your config is already a folder; put it in your dotfiles repo.

Put formatting and lint rules in the project (.editorconfig, Prettier or Biome config), not in personal editor settings, so the whole team gets the same result. Compare options in the IDE directory.

Step 6: Containers for databases and services

Run Postgres, Redis and similar services in containers instead of installing them on your machine:

docker run -d --name pg -e POSTGRES_PASSWORD=dev -p 5432:5432 postgres:18

Check the license before you install Docker Desktop at work. Per Docker's pricing FAQ, it is free for personal use, education, non-commercial open source and companies with fewer than 250 employees and less than $10 million in annual revenue; larger companies need a paid subscription. Docker Engine itself is open source. On macOS, Colima runs Docker Engine in a lightweight VM, and Podman Desktop is another free option.

Step 7: API client and AI assistant

For APIs, curl plus jq covers quick checks. For saved collections, Bruno and Hoppscotch are popular free alternatives to Postman; Bruno stores requests as files in your repo.

For an AI coding assistant, pick one and integrate it where you work (editor plugin or terminal agent). Costs vary a lot by model and usage, so compare them on AI model pricing. Treat AI output like a pull request from a new teammate: review it and run the tests.

Step 8: Make it reproducible with dotfiles

Create a Git repository (often called dotfiles) that holds your shell config, Git config, editor settings and a list of packages. With Homebrew you can export and reinstall everything:

brew bundle dump --file=~/dotfiles/Brewfile   # save what is installed
brew bundle --file=~/dotfiles/Brewfile        # install it on a new machine

On Windows, winget export -o packages.json and winget import -i packages.json do the same. Add a short install.sh that symlinks your config files into place. Never commit secrets: keep API keys in a password manager or a .env file listed in .gitignore.

Keep the toolkit lean

• Add a tool only for a repeated pain. If you hit the same problem three times, look for a tool. Otherwise, skip it.
• Review once a year. Remove tools you no longer open, update runtimes off end-of-life versions.
• Prefer project-level config. mise.toml, .editorconfig, lint config and a Makefile or package.json scripts make your toolkit work for teammates too.

For new tools worth trying, browse the CLI tools directory on DevHunt, where makers launch developer tools every week.

FAQ

What is a dev toolkit?

A dev toolkit is the collection of software a developer uses daily: editor, terminal, version control, runtime and package managers, testing and debugging tools, containers and API clients. A good one is consistent across projects and can be reinstalled from a script.

What should be in a beginner developer's toolkit?

Start with a code editor (VS Code is the common choice), Git and a GitHub account, one language runtime installed through a version manager, and a browser's built-in DevTools. Add containers, an API client and CLI utilities when you need them.

Are there free developer toolkits?

Yes. Every default in the checklist above has a free option: Homebrew, winget, mise, Git, VS Code, ripgrep, fzf, jq, Bruno and Colima are all free. Docker Desktop is free for individuals and small companies. Students can also get paid tools free through programs like the GitHub Student Developer Pack; see developer perks.

How do I move my dev setup to a new computer?

Keep a dotfiles repository with your configs and a package list (Brewfile on macOS/Linux, a winget export on Windows). On the new machine, install the package manager, clone the repo, run the install script, then sign in to your editor's settings sync and gh auth login.