Development Tools

Chapter 10 The Terminal and Shell Scripting

You used the terminal in Chapter 03 to run Python. Now you'll learn it as a power tool. The ~15 commands below are the ones professionals use daily. Everything else you can look up.

Essential Commands

Shell Scripts

A shell script is a file of commands that run in sequence. Start every script with a shebang line that tells the OS which interpreter to use:

#!/bin/bash
echo "Running tests..."
python3 -m pytest
echo "Done."

Save as run_tests.sh, make executable with chmod +x run_tests.sh, then run with ./run_tests.sh.

Piping: Composing Small Tools

The | operator sends the output of one command to the input of another. > writes output to a file.

Environment Variables and PATH

Environment variables are system-wide settings. PATH tells the shell where to find commands. When you get command not found, it means the program isn't in any directory listed in PATH.

export API_KEY="sk-abc123"   # set a variable
echo $PATH                    # see your PATH

SSH Basics

SSH (Secure Shell) lets you connect to remote machines via the terminal. You'll encounter it when deploying code or accessing cloud servers. Generate a key pair with ssh-keygen -t ed25519, then add the public key (~/.ssh/id_ed25519.pub) to remote services (you'll set this up with a specific service in Chapter 12). Connect: ssh user@hostname.

tmux: Terminal Multiplexer

Concept: A terminal multiplexer lets you run multiple persistent shell sessions inside a single terminal window. You can split panes, switch between tabs, and detach entirely—leaving everything running in the background. This is essential for any workflow where you need to monitor multiple processes simultaneously, and it becomes critical when orchestrating multiple AI agents.

Installing tmux

Core Concepts

tmux has three layers:

Getting Started

Every tmux command inside a session starts with the prefix key: Ctrl + B. You press the prefix, release it, then press the next key. This is the most common stumbling block—you're pressing a two-step combo, not holding everything at once.

tmux Hotkeys Reference

All hotkeys below assume you press Ctrl + B first (the prefix), release it, then press the next key.

Session Management

Window Management (Tabs)

Pane Management (Splits)

Copy Mode and Scrollback

In copy mode, navigate with arrow keys. Press Space to start selection, move to select text, press Enter to copy. Press q to exit copy mode.

Recommended tmux Configuration

Create ~/.tmux.conf with these settings to make tmux more usable:

# ~/.tmux.conf

# Use Ctrl+A as prefix instead of Ctrl+B (easier to reach)
unbind C-b
set -g prefix C-a
bind C-a send-prefix

# Split panes with | and - (easier to remember)
bind | split-window -h -c "#{pane_current_path}"
bind - split-window -v -c "#{pane_current_path}"

# New windows open in current directory
bind c new-window -c "#{pane_current_path}"

# Navigate panes with Alt+Arrow (no prefix needed)
bind -n M-Left select-pane -L
bind -n M-Right select-pane -R
bind -n M-Up select-pane -U
bind -n M-Down select-pane -D

# Enable mouse support (click to select pane, scroll to scroll)
set -g mouse on

# Start window numbering at 1 (not 0)
set -g base-index 1
setw -g pane-base-index 1

# Renumber windows when one is closed
set -g renumber-windows on

# Increase scrollback buffer
set -g history-limit 50000

# Reduce escape delay (faster for vim/nano users)
set -sg escape-time 10

# Status bar styling
set -g status-style bg=black,fg=white
set -g status-left "[#S] "
set -g status-right "%H:%M"

After saving, reload with tmux source-file ~/.tmux.conf (or start a new session).

Real-World tmux Workflow

Here's how a typical multi-agent development session looks:

Terminal Speed: Advanced Hotkeys

You learned basic shell hotkeys in Chapter 03. Here are the advanced ones that make a real difference when you're working all day in the terminal:

History Power Moves

TaskForge Connection

You'll use pipes and grep to inspect TaskForge: grep "def " taskforge.py lists all function definitions. When you manage agents in Phase 5, you'll use tmux to run multiple Claude Code sessions simultaneously—one session per agent, each in its own tmux window, all within a single session you can detach from and reattach to.

Micro-Exercises

echo 'hello world' | wc -w

ls | head -5

Interactive Exercises

Chapter 11 Version Control with Git

Git tracks every change to your code. Think of it as a time machine for your project—you can go back to any previous state. Branches are like parallel timelines: you can work on a new feature in one timeline while keeping the main timeline stable. If the experiment fails, you discard that timeline. If it succeeds, you merge it back. This is how AI agents work on your code without breaking what already works.

Core Commands

Merge Conflicts

When two branches change the same line, git can't decide which version to keep. It marks the conflict with <<<<<<</=======/>>>>>>> markers. You choose the correct version, delete the markers, and commit.

Worktrees

git worktree add ../feature-branch feature creates a separate working directory for a branch. Claude Code multi-agent setups use worktrees so each agent has its own filesystem.

TaskForge Connection

In the Phase 3 Gate, you'll turn TaskForge into a git repo with 3+ commits and a merged branch. This is how every professional project is managed.

Micro-Exercises

git init
echo "# My Project" > README.md
git add README.md
git commit -m "initial commit"
git log --oneline

git branch feature
git switch feature
echo "new feature" > feature.txt
git add feature.txt
git commit -m "add feature"
git switch main

Interactive Exercises

Chapter 12 Git Remote and GitHub

What Is a Remote?

So far, all your Git work has been local—commits, branches, and merges living only on your machine. A remote is a copy of your repository hosted on another server, typically GitHub. Your local repo is where you work. The remote repo is where you share, back up, and collaborate. Think of it this way: your local repo is your notebook; the remote is the shared whiteboard everyone on the team can see.

When you push, you copy your commits to the remote. When you pull, you copy the remote's commits to your local repo. The two stay in sync through these explicit actions—nothing happens automatically.

GitHub Account Setup

If you don't have a GitHub account yet:

1. Go to github.com and click Sign up.
2. Choose a username, enter your email, and set a password.
3. Once logged in, click the + icon (top right) → New repository.
4. Name it taskforge, leave it public, and do not initialize with a README (you already have one locally).
5. GitHub shows you the commands to connect your local repo. You'll use those next.

Connecting Local to Remote

After creating an empty repository on GitHub, connect your local repo to it:

git remote add origin https://github.com/YOUR-USERNAME/taskforge.git

origin is the conventional name for your primary remote. You can name it anything, but origin is universal. Verify the connection:

git remote -v

You should see two lines—one for fetch and one for push—both pointing to your GitHub URL.

Push and Pull

Push sends your local commits to the remote. Pull fetches the remote's commits and merges them into your local branch.

# Send your commits to GitHub
git push origin main

# Get new commits from GitHub
git pull origin main

The first time you push a brand-new branch, use -u to set up tracking:

git push -u origin main

After that, git push and git pull work without specifying the remote and branch every time.

git pull origin main    # fetch and merge remote changes
git push origin main    # now push succeeds

Cloning

git clone downloads an entire repository—all files, all history, all branches—from a remote to your machine:

git clone https://github.com/someone/their-project.git

This creates a new directory named their-project/ with a fully functional Git repo inside. The remote origin is already set up, pointing back to the URL you cloned from. This is how you get someone else's project onto your machine.

Branches on Remotes

Branches exist independently on your local machine and on the remote. To push a local branch to GitHub:

git push origin feature-branch

This creates the branch on GitHub if it doesn't exist. To set up tracking (so Git knows the local branch corresponds to the remote one):

git push -u origin feature-branch

After tracking is set, git push and git pull automatically know which remote branch to use. To see all branches, including remote ones:

git branch -a

.gitignore

A .gitignore file tells Git which files and directories to never track. This keeps your repository clean by excluding generated files, secrets, and environment-specific artifacts.

# Byte-compiled Python files
*.pyc
__pycache__/

# Virtual environments
.venv/
venv/

# Environment variables / secrets
.env

# IDE settings
.vscode/
.idea/

# OS files
.DS_Store

# Node (if applicable)
node_modules/

Pattern syntax:

Pull Requests

A pull request (PR) is a proposal to merge one branch into another. It's the core of code review: you show your changes, teammates review them, and only after approval does the code merge into main. The workflow:

1. Branch: Create a feature branch locally. git switch -c add-delete-feature
2. Work: Make changes, commit them.
3. Push: git push -u origin add-delete-feature
4. Open PR: Go to GitHub. You'll see a banner: "Compare & pull request." Click it. Write a description of what you changed and why.
5. Review: Teammates read your code, leave comments, request changes.
6. Merge: Once approved, click "Merge pull request" on GitHub.

Even solo developers use PRs—they create a clean record of what changed and why, and they're how Claude Code submits work for your review in later phases.

SSH Keys

GitHub supports two connection methods: HTTPS and SSH. HTTPS asks for credentials on every push. SSH uses a key pair so you authenticate automatically.

Generate an SSH key:

ssh-keygen -t ed25519 -C "your-email@example.com"

Press Enter to accept the default location. Set a passphrase or leave it empty. Then add the public key to GitHub:

1. Copy your public key: cat ~/.ssh/id_ed25519.pub
2. GitHub → Settings → SSH and GPG keys → New SSH key
3. Paste the key and save.

Test the connection:

ssh -T git@github.com

You should see: Hi username! You've successfully authenticated. Now you can use SSH URLs (git@github.com:user/repo.git) instead of HTTPS.

Common Misconceptions

TaskForge Connection

Push TaskForge to a GitHub repository. Create a .gitignore that excludes __pycache__/, .venv/, *.pyc, and .env. Create a feature branch, push it to GitHub, and open a pull request—even if you're the only reviewer. This is the same workflow you'll use when Claude Code creates branches and PRs for your review in Phase 4.

Micro-Exercises

git remote add origin https://github.com/YOUR-USERNAME/taskforge.git
git push -u origin main

__pycache__/
.venv/
*.pyc

git add .gitignore
git commit -m "add .gitignore"
git push

git switch -c add-delete-feature
# make a change (e.g., add a delete command to TaskForge)
git add .
git commit -m "add delete feature"
git push -u origin add-delete-feature

Interactive Exercises

Phase 3 Gate Checkpoint & TaskForge on GitHub

What You Can Now Do