tools

Developer Tools

Overview

These are the tools every developer needs regardless of language or framework — the bedrock of the development environment. Whether you are writing Python, C#, Rust, or JavaScript, you will reach for these tools daily: a shell to run commands, Git to track changes, a package manager to install software, and containers to ship reproducible environments. Mastering this foundational layer makes everything built on top of it faster and more reliable.

Tool Landscape

┌─────────────────────────────────────────────────────────────┐
│                    Developer Tools                          │
├─────────────────────────────────────────────────────────────┤
│  Shells:            PowerShell Core, Bash/Zsh               │
│  Version Control:   Git                                     │
│  Package Managers:  choco, winget, brew, apt, snap          │
│  Containers:        Docker, Podman                          │
│  Remote Access:     SSH, SCP                                │
│  HTTP Clients:      curl, wget, HTTPie                      │
│  Data Processing:   jq, yq                                  │
│  Pattern Matching:  Regular Expressions                     │
│  Build Runners:     Make, Just, Task                        │
└─────────────────────────────────────────────────────────────┘

Choosing the Right Sub-Skill

Need	Look In
Writing cross-platform shell scripts	powershell-core
Writing Unix shell scripts, Bash/Zsh automation	bash
Version control, branching, merging, rebasing	git
Installing system-level software and managing OS packages	package-managers
Containerizing applications, Docker Compose, Podman	docker
Remote server access, key management, tunneling	ssh
Making HTTP requests from the command line	curl
Parsing and transforming JSON or YAML data	jq
Text pattern matching, search-and-replace with regex	regex
Running build tasks, command orchestration	make

Platform Availability

Tool	Windows	macOS	Linux
PowerShell Core (pwsh)	Yes (built-in on Win11, installable)	Yes (brew)	Yes (apt/dnf)
Bash	Yes (WSL, Git Bash)	Yes (built-in)	Yes (built-in)
Zsh	Yes (WSL)	Yes (default shell)	Yes (installable)
Git	Yes (winget/choco)	Yes (Xcode CLT / brew)	Yes (apt/dnf)
choco	Yes	No	No
winget	Yes (built-in on Win10+)	No	No
brew	No	Yes	Yes
apt	No	No	Yes (Debian/Ubuntu)
snap	No	No	Yes
Docker	Yes (Docker Desktop / WSL2)	Yes (Docker Desktop)	Yes (native)
Podman	Yes	Yes (brew)	Yes (native)
SSH / SCP	Yes (built-in on Win10+)	Yes (built-in)	Yes (built-in)
curl	Yes (built-in on Win10+)	Yes (built-in)	Yes (built-in)
wget	Yes (choco/winget)	Yes (brew)	Yes (built-in)
HTTPie	Yes (pip/choco)	Yes (brew)	Yes (apt/pip)
jq	Yes (choco/winget)	Yes (brew)	Yes (apt)
yq	Yes (choco/winget)	Yes (brew)	Yes (snap/apt)
Make	Yes (choco, WSL)	Yes (Xcode CLT)	Yes (built-in)
Just	Yes (cargo/choco)	Yes (brew/cargo)	Yes (cargo/apt)
Task (go-task)	Yes (choco/winget)	Yes (brew)	Yes (snap/apt)

Best Practices

• Automate your setup with dotfiles. Keep your shell configuration, Git config, and tool settings in a version-controlled dotfiles repository so you can bootstrap any new machine in minutes.
• Use cross-platform tools where possible. Prefer tools like PowerShell Core, Docker, and Git that work identically on Windows, macOS, and Linux to reduce friction when switching environments or collaborating across teams.
• Learn at least one shell deeply. Surface-level knowledge of many shells is less valuable than deep expertise in one. Pick PowerShell or Bash and master its scripting, pipeline, and debugging capabilities.
• Version control everything. Not just source code — configuration files, infrastructure definitions, documentation, and scripts all belong in Git.
• Use containers for reproducible environments. Docker and Podman eliminate "works on my machine" problems by packaging applications with their exact dependencies.
• Prefer declarative build runners. Tools like Make, Just, and Task let you define project commands (build, test, lint, deploy) in a single file, making onboarding and CI/CD consistent.