Setting Up Your Development Environment

Your development environment matters more than most developers admit. The difference between a well-configured setup and a default installation is hours saved per week - not from any single moment, but from hundreds of small efficiencies that compound.

I've refined my setup over ten years of professional development. Some things I wished I'd learned earlier, others I've picked up from colleagues with better tools than me. Here's what actually makes a difference.

The Terminal

If you're only going to improve one thing, make it your terminal. A good terminal setup makes everything faster - navigating directories, managing git, running commands, connecting to servers.

Shell Choice

If you're on macOS or Linux, consider switching from bash to zsh (now default on macOS) or fish. These modern shells offer better autocomplete, syntax highlighting, and plugin ecosystems.

# Install zsh and Oh My Zsh
# On macOS (zsh is already default):
sh -c "$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

# On Ubuntu:
sudo apt install zsh
chsh -s $(which zsh)
# Then install Oh My Zsh as above

Oh My Zsh gives you plugins for git, docker, node, and basically every common tool. The git plugin alone is worth it - shortcuts like gst for git status and gco for git checkout add up fast.

Essential Terminal Tools

# Install these tools (macOS with Homebrew):
brew install fzf ripgrep bat eza

# After installing fzf, run this to set up shell integration:
$(brew --prefix)/opt/fzf/install

Version Management

Don't install programming languages directly. Use version managers so you can switch between versions for different projects.

For Node.js: Use nvm (Node Version Manager) or fnm (faster alternative)

For Python: Use pyenv

For Ruby: Use rbenv or asdf

Or use asdf for everything - it's a universal version manager that handles multiple languages with one tool.

# Install asdf
git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch v0.13.1
# Add to your .zshrc:
. "$HOME/.asdf/asdf.sh"

# Then add plugins and install versions:
asdf plugin add nodejs
asdf plugin add python
asdf install nodejs 20.10.0
asdf global nodejs 20.10.0

Editor Configuration

I'm not going to tell you which editor to use - I covered that in another article. What I will say is: learn your editor deeply. Most developers use maybe 20% of their editor's features.

Whatever editor you use:

• Learn the keyboard shortcuts. Print out a cheat sheet if you have to.
• Set up code formatting to run on save. Use Prettier for JavaScript/TypeScript, Black for Python.
• Configure linting and get used to fixing issues as you code, not later.
• Learn multi-cursor editing. It sounds gimmicky until you use it.
• Set up snippet shortcuts for code you write repeatedly.

Git Configuration

A few git configs that make life better:

# Better default branch name
git config --global init.defaultBranch main

# Better diff algorithm
git config --global diff.algorithm histogram

# Autocorrect typos
git config --global help.autocorrect 10

# Useful aliases
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
git config --global alias.last 'log -1 HEAD'
git config --global alias.unstage 'reset HEAD --'

Also set up git hooks for your projects. Pre-commit hooks that run linting and formatting catch issues before they get into your history.

Docker for Development

If you're doing backend development, Docker is worth learning. Running databases, message queues, and other services in containers keeps your system clean and makes setup reproducible.

# Example: spin up PostgreSQL without installing it
docker run --name my-postgres -e POSTGRES_PASSWORD=mysecret -p 5432:5432 -d postgres

# Redis
docker run --name my-redis -p 6379:6379 -d redis

Use Docker Compose for multi-container development environments. Define your database, cache, and other services in one file and start everything with docker compose up.

Dotfiles

Keep your configuration files in a git repository. When you set up a new machine, you clone your dotfiles and you're back to your comfortable environment.

The basics to track:

• .zshrc or .bashrc - shell configuration
• .gitconfig - git configuration
• Editor settings (for VS Code, the settings.json and extensions list)
• Any tool-specific configs you've customized

There are dotfile management tools (stow, chezmoi, etc.) but you can start simple - just a git repo with symlinks to your home directory.

Don't Over-Engineer

A word of caution: it's easy to spend more time configuring your environment than actually coding. The goal is productivity, not a YouTube-worthy setup video.

Start with defaults. When something frustrates you repeatedly, fix it. When you see a colleague do something faster, ask how. Build your environment gradually based on actual needs.

The best development environment is one you know deeply, not one with the most plugins.