Developer Tools Mastery: CLI, Web & Desktop - The Complete Toolkit

Introduction: Tools Are Force Multipliers

Your tools don’t make you productive. But bad tools make you unproductive.

Here’s the difference:

Bad Tools:

• Slow
• Require constant manual work
• Don’t integrate with your workflow
• Make simple tasks complex

Result: You spend energy fighting the tool instead of solving problems.

Good Tools:

• Fast
• Automate repetitive work
• Integrate seamlessly
• Make complex tasks simple

Result: You spend energy solving problems instead of fighting tools.

A developer with mediocre skills and excellent tools outships a brilliant developer with bad tools.

Why? Because the brilliant developer spends half their time fighting tools.

This guide teaches you the tools that matter. Not the trendy ones. Not the ones with the best marketing.

The ones that actually make you faster.

I’ve tested hundreds. I’m recommending the ones that genuinely changed how I work.

---

Chapter 1: CLI Tools - The Foundation

CLI (Command-Line Interface) tools are where productivity lives.

Why? Because they’re:

• Fast (no GUI overhead)
• Scriptable (automate workflows)
• Portable (work anywhere)
• Powerful (can do anything)

Most developers use only 20% of CLI capability. Learning the remaining 80% multiplies your speed.

Shell: Fish or Zsh

Default shell: Bash (comes with everything)

Better: Zsh or Fish

Best: Fish

Fish is:

• Faster (better autocomplete)
• More intuitive (makes sense by default)
• Better history (remembers what you did)
• Better syntax (readable scripts)

Installation:

# macOS
brew install fish

# Linux
sudo apt install fish

# Set as default
chsh -s /usr/bin/fish

Time saved: 2-3 hours per week (faster typing, better autocomplete, better history)

---

Oh My Fish (Framework)

Fish without configuration is good. Fish with Oh My Fish is amazing.

Oh My Fish is a plugin manager for Fish. Massive ecosystem.

Essential plugins:

# Installation
curl https://get.oh-my.fish | fish

# Install plugins
omf install nvm
omf install weather
omf install z

Key plugins:

• nvm - Node version management
• z - Smart directory jumping (jump to frequently used dirs)
• fzf - Fuzzy finder (game changer)

Time saved: 1-2 hours per week (faster navigation, easier version switching)

---

Git - Beyond Basics

Most developers use 10% of Git.

# Common (everyone uses)
git status
git add
git commit
git push
git pull

# Intermediate (most people don't use)
git rebase
git stash
git cherry-pick

# Advanced (changes your life)
git worktree
git bisect
git reflog

Most useful advanced commands:

git worktree:

Create multiple working directories from same repo.

# Main work in main branch
git worktree add ../feature-x feature/x

# New terminal, different directory
cd ../feature-x
# You're on feature/x branch
# Make changes independently

Benefit: Work on multiple features simultaneously without switching branches.

Time saved: 1-2 hours per week (no branch thrashing)

---

git bisect:

Find which commit broke something.

git bisect start
git bisect bad     # Current commit is broken
git bisect good v1.0  # This commit was good

# Git checks out middle commit
# You test it
git bisect good    # or git bisect bad

# Repeat until found
git bisect reset   # Go back to normal

Benefit: Find bugs 10x faster than manual searching.

Time saved: 2-3 hours per week (on average, when you hit a bug)

---

Lazygit - Git UI Without Leaving Terminal

Lazygit is a terminal UI for Git.

Much faster than CLI for complex operations.

# Installation
brew install lazygit

# Usage
lazygit

What it does:

• Visual staging (see diffs as you add)
• Visual rebasing (drag-drop reorder commits)
• Visual stashing (pop specific stashes)
• Visual merging (see conflicts clearly)

Time saved: 3-4 hours per week (faster commits, rebases, complex git operations)

---

FZF - Fuzzy Finder

FZF is a fuzzy search tool. Game changer for productivity.

# Installation
brew install fzf

# Usage: Search files
vim $(fzf)

# Usage: Search git branches
git checkout $(git branch | fzf)

# Usage: Search git commits
git log --oneline | fzf

Instead of remembering full names, you fuzzily search.

Type re → shows all files matching re → select.

Time saved: 2-3 hours per week (faster file/branch navigation)

---

Make - Task Runner

Make is a task runner. Use it to automate common commands.

.PHONY: test build deploy

test:
	go test ./...

build:
	go build -o myapp

deploy:
	./scripts/deploy.sh

lint:
	golangci-lint run

fmt:
	go fmt ./...

clean:
	rm -f myapp
	go clean

Then:

make test      # Instead of: go test ./...
make deploy    # Instead of: ./scripts/deploy.sh
make clean     # Instead of: rm -f myapp && go clean

Benefit: Consistency. Everyone runs same commands. Easier to automate.

Time saved: 1-2 hours per week (remembering commands, consistency)

---

HTTPie - Better Curl

Curl is powerful but complex.

HTTPie is curl but with sane defaults.

# Install
brew install httpie

# Usage (way simpler than curl)
http GET https://api.example.com/users
http POST https://api.example.com/users name=john email=john@example.com
http PUT https://api.example.com/users/1 status=active

Compare to curl:

curl -X GET https://api.example.com/users
curl -X POST -H "Content-Type: application/json" -d '{"name":"john","email":"john@example.com"}' https://api.example.com/users

HTTPie is 10x simpler.

Time saved: 1-2 hours per week (testing APIs, debugging)

---

Ripgrep (rg) - Better grep

Grep is slow for searching large codebases.

Ripgrep is grep on steroids.

# Install
brew install ripgrep

# Usage
rg "function_name"
rg "TODO" src/
rg -l "console.log"    # Just file names
rg "error" --type go   # Only Go files

10x faster than grep. Simpler syntax.

Time saved: 1-2 hours per week (searching code)

---

Jq - JSON Processor

Most APIs return JSON. Jq makes working with JSON trivial.

# Install
brew install jq

# Usage
curl https://api.example.com/users | jq '.'

# Get specific field
curl https://api.example.com/users | jq '.name'

# Filter
curl https://api.example.com/users | jq '.[] | select(.age > 30)'

# Transform
curl https://api.example.com/users | jq '[.[] | {name, age}]'

Instead of parsing JSON manually, use jq.

Time saved: 2-3 hours per week (API debugging, JSON processing)

---

Chapter 2: Code Editors - Where You Spend Most Time

Your code editor is your primary tool. Choose wisely.

VS Code - The Standard

Pros:

• Free
• Works everywhere (Windows, Mac, Linux)
• Massive plugin ecosystem
• Fast
• Excellent Git integration

Cons:

• Electron (slower than native)
• Heavy on RAM

VS Code is the right choice for 90% of developers.

Essential plugins:

1. Prettier (Code Formatter)

Auto-formats code on save. Removes formatting debates.

{
  "editor.formatOnSave": true,
  "editor.defaultFormatter": "esbenp.prettier-vscode"
}

Time saved: 2-3 hours per week (no formatting arguments)

---

2. GitLens

Blame annotations, commit history, branch info - in the editor.

Hover over code → see who wrote it, when, what commit.

Time saved: 1-2 hours per week (understanding code history)

---

3. ESLint / Golangci-lint

Real-time linting. Catch errors before running.

Time saved: 2-3 hours per week (fewer bugs in testing)

---

4. Remote SSH

Edit code on remote server directly in VS Code.

Game changer for deploying/debugging.

Time saved: 1-2 hours per week (remote work)

---

5. Thunder Client or REST Client

Make HTTP requests from editor.

No need to switch to Postman or curl.

### Get users
GET https://api.example.com/users

### Create user
POST https://api.example.com/users
Content-Type: application/json

{
  "name": "john",
  "email": "john@example.com"
}

Time saved: 1-2 hours per week (API testing)

---

Vim/Neovim - For Terminal Lovers

Vim is hard to learn but massively powerful once you know it.

Why Vim:

• Works in any terminal
• Extremely fast once you know keybindings
• No mouse needed
• Portable (configs work everywhere)

Why not Vim:

• Steep learning curve (6 months to productivity)
• Requires configuration
• Not for everyone

If you use terminal a lot (remote SSH, servers), Vim is worth learning.

# Install Neovim (modern Vim)
brew install neovim

# Configuration in ~/.config/nvim/init.vim

Time saved (after learning): 3-4 hours per week (fast editing, no mouse)

---

Chapter 3: CLI Tools for Specific Tasks

Docker - Containerization

Docker lets you package applications with dependencies.

# Install
brew install docker

# Usage
docker build -t myapp .
docker run -p 3000:3000 myapp
docker ps
docker logs container_id

Without Docker: “It works on my machine but not production”

With Docker: “If it works in Docker, it works everywhere”

Time saved: 4-5 hours per week (environment consistency, deployment simplicity)

---

Kubernetes (kubectl) - Container Orchestration

Kubernetes manages Docker containers at scale.

For small projects: Skip Kubernetes. Too complex.

For large projects: Essential.

# Install
brew install kubernetes-cli

# Usage
kubectl get pods
kubectl logs pod_name
kubectl apply -f deployment.yaml
kubectl port-forward service/myapp 3000:3000

---

AWS CLI / Google Cloud CLI

Command-line access to cloud infrastructure.

# Install AWS CLI
brew install awscli

# Usage
aws s3 ls
aws ec2 describe-instances
aws lambda invoke --function-name myfunction response.json

Benefit: Automate infrastructure operations.

Time saved: 2-3 hours per week (infrastructure management)

---

Terraform - Infrastructure as Code

Define infrastructure in code. Version control it. Deploy it.

resource "aws_s3_bucket" "my_bucket" {
  bucket = "my-unique-bucket"
}

resource "aws_ec2_instance" "web" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
}

Then:

terraform init
terraform plan    # See what will change
terraform apply   # Deploy

Benefit: Reproducible infrastructure. Easy to version control.

Time saved: 3-4 hours per week (infrastructure consistency, reproducibility)

---

Bash/Zsh Scripts - Automation

Write scripts to automate repetitive tasks.

#!/bin/bash
# deploy.sh - Deploy script

set -e  # Exit on error

echo "Building..."
go build -o myapp

echo "Running tests..."
go test ./...

echo "Deploying..."
scp myapp user@server:/app/
ssh user@server "systemctl restart myapp"

echo "✓ Deployed"

Then:

./deploy.sh

Time saved: 5-10 hours per week (automation of manual tasks)

---

Chapter 4: Web Tools & SaaS

GitHub/GitLab - Source Control

Essential. Don’t use anything else unless you have a good reason.

GitHub is standard. Use GitHub.

Features:

• Version control
• Code review (pull requests)
• CI/CD integration
• Project management
• Discussions

Cost: Free (with paid private repos)

---

Vercel / Railway - Deployment

Deploy web applications with one command.

# Vercel
vercel deploy

# Railway
railway up

No infrastructure management. No DevOps needed.

Perfect for side projects and startups.

Cost: Free tier, then $5-20+/month

---

Netlify - Static Site Hosting

Host static sites (Jekyll, Hugo, Next.js, etc.)

Connect to GitHub. Auto-deploys on push.

# Super simple
git push → Netlify deploys

Cost: Free tier, then $5-20+/month

---

Figma - Design Tool

Most developers avoid design. Don’t.

Figma is browser-based, collaborative design tool.

Learn Figma → design your own mockups → communicate with designers better.

Cost: Free tier, $15+/month professional

---

Notion - Knowledge Base

Organize documentation, notes, databases.

Collaborative. Powerful. Beautiful.

Many teams use Notion for:

• Team wiki
• Product requirements
• Decision records
• Team handbook

Cost: Free tier, $10+/month professional

---

Linear - Issue Tracking

GitHub issues are fine, but Linear is better for serious teams.

Better workflow. Better UI. Better performance.

Cost: Free tier, $10+/month

---

Slack - Team Communication

Essential for team collaboration.

Integrate everything: GitHub, deployments, alerts, monitoring.

Cost: Free tier (limited history), $12.50+/user/month pro

---

1Password - Password Manager

Never store passwords in plain text. Never use same password twice.

1Password (or Bitwarden, or KeePass) solves this.

Cost: $2.99/month or $34.99/year

---

Loom - Screen Recording

Record video explanations. Better than writing long docs.

Share videos instead of writing.

Cost: Free tier, $5-25+/month pro

---

Chapter 5: Desktop Applications

Raycast (macOS) / Albert (Linux) - App Launcher & Command Palette

Raycast is Alfred on steroids.

Open any app, run any command, search anything.

Cmd+Space → type "deploy" → Shows deploy script
Cmd+Space → type "github" → Opens GitHub
Cmd+Space → type "calculator" → Runs calculator

Massively faster than mouse.

Cost: Free, $10/month pro

---

Obsidian - Local Note-Taking

Better than Notion for personal notes (you own your data).

Write in Markdown. Version control with Git.

Note.md → Git repo → Sync everywhere

Features:

• Backlinks (connect notes)
• Tags (organize)
• Search (find anything)
• Sync (to all devices)

Cost: Free, $10/month sync

---

Insomnia / Postman - API Testing

Make API requests. Save them. Reuse them.

Better than HTTPie for team collaboration.

GET /users
GET /users/1
POST /users
DELETE /users/1

Save all requests. Share with team.

Cost: Free tier, $10-20+/month pro

---

DBeaver - Database Client

Universal database client. Works with PostgreSQL, MySQL, MongoDB, etc.

UI-based database exploration, queries, exports.

Cost: Free community edition, $99/year pro

---

Warp - Terminal

Modern terminal emulator (macOS/Linux).

Faster than default terminal. Better UI. Better autocomplete.

Cost: Free, $25/month pro

---

OmniGraffle - Diagrams

Draw architecture diagrams, flowcharts, wireframes.

Better than Lucidchart for technical diagrams.

Cost: $200 one-time

---

Chapter 6: Productivity Tools

Alfred (macOS) - Spotlight on Steroids

Alfred is an app launcher and command palette for macOS.

⌘Space → type anything → instant results

Workflows let you automate custom commands.

Cost: Free basic, $69 pro

---

Amphetamine (macOS) - Prevent Sleep

Keep your Mac awake without touching keyboard.

Useful for long-running processes.

Cost: Free (App Store)

---

TimeMachineStatus (macOS) - Backup Monitor

Ensures backups are happening. Peace of mind.

Cost: Free

---

Chapter 7: Browser Tools for Developers

Chrome DevTools - Built In

Best browser debugging tools.

Cmd+Option+I → Open DevTools

Essential features:

• Network tab (see HTTP requests)
• Console (run JavaScript)
• Elements (inspect HTML)
• Performance (profile)

Mastery time: 3-4 hours learning. Benefit: 5-10 hours/week saved (debugging)

---

React Developer Tools / Vue DevTools

Browser extensions for debugging React/Vue apps.

Inspect component hierarchy. See props and state in real-time.

Time saved: 2-3 hours per week (debugging frontend)

---

Redux DevTools

Debug Redux state. See state changes over time. Time travel.

Time saved: 2-3 hours per week (debugging state)

---

JSON Formatter

Auto-format JSON in browser.

Makes reading API responses easy.

---

Lighthouse

Built into Chrome DevTools. Audits website performance, accessibility, SEO.

Run → See scores → Get recommendations.

Time saved: 2-3 hours per week (optimization)

---

Chapter 8: Monitoring & Logging

DataDog - Application Monitoring

Monitor application health, performance, errors.

See what’s happening in production in real-time.

CPU usage: 45%
Memory: 2.3 GB
Errors/min: 0.5

Cost: Free tier, $15+/day pricing

---

Sentry - Error Tracking

When errors happen in production, Sentry captures them.

See:

• Stack trace
• User who hit it
• Browser/device
• Steps to reproduce

Time saved: 5-10 hours per week (production debugging)

---

Prometheus - Metrics

Collect metrics from your application.

http_requests_total{method="GET",status="200"}
duration_seconds
errors_total

Then visualize with Grafana.

---

Grafana - Visualization

Create dashboards to visualize metrics.

Real-time graphs. Beautiful. Alerting.

Cost: Free, $50+/month pro

---

ELK Stack - Logging

Elasticsearch + Logstash + Kibana.

Centralize all logs. Search. Analyze. Alert.

Cost: Free to host, $300+/month for Elastic Cloud

---

Chapter 9: Open Source Tools Worth Knowing

Homebrew (macOS) - Package Manager

Install any open source tool with one command.

brew install git
brew install node
brew install postgresql

Cost: Free

---

Git - Version Control

Everyone uses it. Master it.

git init
git add
git commit
git push
git pull
git branch
git merge

Cost: Free

---

Nginx - Web Server

Serve static files. Reverse proxy. Load balance.

server {
    listen 80;
    server_name example.com;

    location / {
        proxy_pass http://localhost:3000;
    }
}

Cost: Free

---

PostgreSQL - Database

Production-grade SQL database. Better than MySQL.

createdb myapp
psql myapp

Cost: Free

---

Redis - Cache/Queue

In-memory data store. Perfect for caching and queues.

redis-cli
LPUSH queue task1
BRPOP queue 0

Cost: Free

---

RabbitMQ - Message Queue

Asynchronous task processing. Reliable delivery.

Cost: Free

---

Chapter 10: Integrating Your Toolset

Having great tools is half the battle. Integrating them is the other half.

The Integration Philosophy

Tools should talk to each other. Automatically.

Bad: Manual hand-offs between tools

Good: Automatic data flow between tools

Example: Deployment Workflow

1. Push code to GitHub
   ↓
2. GitHub webhook triggers CI/CD
   ↓
3. Tests run automatically
   ↓
4. If tests pass, deploy to Vercel
   ↓
5. Slack notification: "Deployment successful"
   ↓
6. Sentry monitors for errors
   ↓
7. If error rate spikes, alert in Slack

This entire workflow is automatic. Zero manual steps.

---

Setting Up Automation

GitHub Actions (Free CI/CD)

# .github/workflows/deploy.yml
name: Deploy

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - run: npm test
      - run: npm run build
      - run: npx vercel --prod

Push → Tests run → Deploy → Done.

---

Slack Webhooks (Notifications)

Send messages to Slack from any tool.

curl -X POST \
  -H 'Content-type: application/json' \
  --data '{"text":"Deployment successful"}' \
  $SLACK_WEBHOOK_URL

Now every tool can notify your team.

---

IFTTT / Zapier (General Integration)

Connect almost any tool to any other tool without coding.

Example:

• GitHub release published → Send email
• Slack message → Create Linear issue
• Form submission → Add to Google Sheets

---

Chapter 11: Choosing Your Tools

Not all tools are right for you. Here’s how to choose.

The Tool Selection Criteria

1. Does it solve a real problem?

Not: “This looks cool.”

Yes: “This eliminates 3 hours of manual work per week.”

---

2. Is it free or cheap?

Don’t pay for every tool.

Free tier or < $20/month per tool.

Exception: If it saves 10+ hours/week, pay for it.

---

3. Does it integrate with your other tools?

Bad: Tool works in isolation. Manual hand-offs.

Good: Tool integrates with GitHub, Slack, etc.

---

4. Is it stable?

Don’t use beta software for critical work.

Use stable, proven tools.

---

5. Can you learn it quickly?

If it takes 3 weeks to learn, it’s not worth it (usually).

Prefer tools with low learning curve.

Exception: Worth learning once (Git, SQL, Docker)

---

Tool Fatigue

Warning: Don’t try to use every tool.

“Tool fatigue” = spending more time learning tools than actually working.

Better: Master 5-10 core tools deeply.

---

Conclusion: Your Toolkit

You don’t need every tool. You need the right tools for your work.

Start with:

Essential (everyone):

• Terminal (Fish)
• Code editor (VS Code)
• Git (Lazygit)
• Browser (Chrome)

Your specialty (depends on what you do):

• If you do DevOps: Docker, Kubernetes, Terraform
• If you do backend: Database tools, API tools, monitoring
• If you do frontend: React DevTools, Chrome DevTools, design tools
• If you do startups: Vercel/Railway, Notion, Linear

Master these. Build your productivity around them.

---

Appendix A: My Recommended Toolkit

Terminal:

• Shell: Fish
• Framework: Oh My Fish
• Terminal: Warp (or default Terminal)
• Fuzzy finder: FZF
• Git UI: Lazygit
• JSON processor: jq
• Search: ripgrep (rg)
• HTTP client: HTTPie

Development:

• Editor: VS Code
• Language-specific: Eslint, golangci-lint, prettier
• Debugger: Browser DevTools
• Remote: VS Code Remote SSH

Infrastructure:

• Containerization: Docker
• Local dev: Docker Compose
• Deployment: Vercel or Railway
• Monitoring: Datadog or Sentry

Productivity:

• Note-taking: Obsidian
• App launcher: Raycast
• Database: DBeaver
• API testing: Insomnia
• Diagrams: OmniGraffle

Team:

• VCS: GitHub
• Chat: Slack
• Issues: Linear
• Docs: Notion
• Video: Loom

Time Investment:

• Week 1: Set up terminal and Git
• Week 2: Master VS Code
• Week 3: Learn Docker
• Month 2: Learn your language-specific tools
• Ongoing: Add tools as needed

Expected Productivity Gains:

• Month 1: 20% faster
• Month 3: 40% faster
• Month 6: 60% faster

---

Appendix B: Free Tools Checklist

MUST HAVE (Free):

☐ Git
☐ VS Code
☐ Fish/Zsh
☐ Chrome
☐ GitHub (free tier)

HIGHLY RECOMMENDED (Free):

☐ Lazygit
☐ FZF
☐ Docker
☐ HTTPie
☐ jq
☐ Prettier
☐ ESLint/Golangci-lint
☐ Obsidian
☐ DBeaver
☐ Vercel (free tier)

NICE TO HAVE (Free tiers available):

☐ Raycast
☐ Sentry
☐ DataDog
☐ Slack (free tier)
☐ Linear (free tier)
☐ GitHub Actions
☐ Netlify
☐ Railway

---

Appendix C: Tool Automation Checklist

AUTOMATE THESE:

☐ Code formatting (Prettier on save)
☐ Linting (ESLint on save)
☐ Testing (Run on git push)
☐ Deployment (GitHub Actions)
☐ Monitoring (Sentry/DataDog)
☐ Notifications (Slack webhooks)
☐ Backups (Automated daily)
☐ Security (Dependabot/Snyk)
☐ Performance monitoring (Lighthouse)
☐ Log aggregation (ELK/Datadog)

BENEFIT:

- No manual steps = less errors
- Consistent = reproducible
- Automated = you work on other things

---

Appendix D: Tool Integration Blueprint

Code Push
   ↓
GitHub Actions Triggered
   ↓
Lint Check
   ↓
Test Suite
   ↓
Build
   ↓
Deploy to Staging (Vercel)
   ↓
Smoke Tests
   ↓
Deploy to Production
   ↓
Sentry Monitoring
   ↓
Slack Notification
   ↓
Datadog Metrics Updated
   ↓
Grafana Dashboard Reflects Changes

Total time: 5 minutes
Manual steps: 0
Errors caught: Automated
---
All automatic. No human intervention needed.