Git, CLI & Developer Tooling

Would You Build a House Without Tools?

A carpenter without a hammer, saw, and measuring tape can't build anything. Similarly, an AI engineer without Git, terminal skills, and proper tooling will struggle with even simple tasks. These tools aren't glamorous but they're what separate beginners from professionals.

The Three Pillars:

• Git - Version control. Track every change, collaborate with teams, never lose code. Like Google Docs history but for code.
• CLI (Command Line Interface) - The terminal. Faster than clicking through GUIs. Essential for servers, Docker, deployment.
• Developer Tools - VS Code, extensions, linters, formatters. Your daily workspace setup.

Why This Is Non-Negotiable for AI:

• Every AI project lives on GitHub/GitLab
• Docker, Kubernetes, cloud deployment = all CLI
• Running LLMs locally (Ollama) = terminal commands
• CI/CD pipelines, testing, debugging = command line
• Collaborating on AI projects = Git workflows

What Git Actually Does:

Imagine you're writing a research paper. You save "paper_v1.doc", "paper_v2.doc", "paper_final.doc", "paper_FINAL_FINAL.doc". Git eliminates this madness. It tracks every change you make, who made it, when, and why. You can go back to any version instantly.

Core Git Concepts:

• Repository (repo) - A project folder tracked by Git
• Commit - A snapshot of your code at a point in time (like a save point in a game)
• Branch - A parallel version of your code (like creating a copy to experiment without affecting the original)
• Merge - Combining changes from one branch into another
• Push/Pull - Push uploads your changes to GitHub. Pull downloads others' changes.
• Clone - Download an entire repository from GitHub to your machine

Essential Git Commands:

git init                    # Start tracking a folder
git clone <url>             # Download a repo
git add .                   # Stage all changes
git commit -m "message"     # Save a snapshot
git push origin main        # Upload to GitHub
git pull origin main        # Download latest changes
git branch feature-x        # Create new branch
git checkout feature-x      # Switch to branch
git merge feature-x         # Merge branch into current
git log --oneline           # See commit history
git status                  # See what changed
git diff                    # See exact changes

Why CLI Over GUI?

GUI (clicking around) is like driving in traffic - slow and limited. CLI is like flying - direct, fast, and you can go anywhere. Plus, servers don't have GUIs! If you deploy AI apps to AWS/GCP, you MUST know CLI.

Must-Know Terminal Commands:

# Navigation
cd /path/to/folder          # Change directory
ls -la                      # List files with details
pwd                         # Print current directory

# File operations
mkdir new-folder            # Create directory
touch file.py               # Create empty file
cp source dest              # Copy
mv source dest              # Move/rename
rm file                     # Delete file
cat file.py                 # View file contents

# Searching
grep "pattern" file.py      # Search in file
find . -name "*.py"         # Find files by name

# Process management
ps aux                      # List running processes
kill PID                    # Stop a process
top                         # System monitor

# Package management
pip install package          # Python packages
npm install package          # Node.js packages

CLI Power Moves:

• Tab completion - Start typing, press Tab to autocomplete
• Ctrl+R - Search command history (game changer!)
• Pipes | - Chain commands: cat file.py | grep "def " | wc -l
• Redirection > - Save output: python script.py > output.txt

VS Code - The #1 Editor for AI:

• Python extension - IntelliSense, debugging, Jupyter support
• GitHub Copilot - AI code completion
• Pylance - Fast Python type checking
• GitLens - Enhanced Git integration
• REST Client - Test APIs directly in VS Code
• Docker extension - Manage containers visually

Essential CLI Tools:

• curl/httpie - Test APIs from terminal
• jq - Parse JSON in terminal (essential for API debugging)
• tmux - Multiple terminal panes in one window
• docker - Container management
• gh - GitHub CLI (create PRs, issues from terminal)

AI-Specific Tools:

• Claude Code - Anthropic's CLI for AI-assisted coding
• Cursor - AI-native code editor
• Ollama - Run LLMs locally
• uv - Ultra-fast Python package manager

Q1: Explain the Git branching workflow.

Answer: Main branch has stable code. Create feature branches for new work. Develop on feature branch, commit often. When ready, create a Pull Request (PR) to merge into main. Team reviews code, approves, then merge. Delete feature branch. This keeps main always deployable.

Q2: What's the difference between git merge and git rebase?

Answer: Merge creates a new merge commit preserving both histories. Rebase replays your commits on top of the target branch, creating a linear history. Merge is safer (preserves history), rebase is cleaner (linear history). Never rebase public/shared branches.

Q3: How do you undo the last commit without losing changes?

Answer: git reset --soft HEAD~1. This undoes the commit but keeps all changes staged. --mixed (default) unstages changes but keeps files. --hard deletes everything (dangerous!). For pushed commits, use git revert to create a new commit that undoes changes.