The Terminal & Linux
- Navigate the filesystem tree with pwd/ls/cd and manipulate it with mkdir/cp/mv/rm
- Inspect files with cat, less, head, and tail without opening an editor
- Chain tools with pipes and redirect output with > and >>
- Search content with grep and find files by name with find
- Read and change permissions, use environment variables and PATH, and write a runnable shell script
| Spaced-rep warm-up: Days 1–5 flashcards | 10 min |
| Concept study: ELI5 + tech (tree, pipes, permissions, PATH) | 20 min |
| Guided: navigation drill, pipeline lab, first shell script | 50 min |
| Practice: the scavenger hunt | 15 min |
| Project: the backup ritual | 15 min |
| Quiz + flashcards | 10 min |
Builds on: Day 1 — Opening a terminal, running scripts · Day 5 — Files and paths
Your computer's desktop — windows, icons, double-clicks — is the showroom: polished, safe, and slow. The terminal is the workshop out back, where the real tools hang on the wall. Each tool does exactly one job and does it fast: ls lists what's on the bench, grep is a magnet that pulls matching lines out of any pile, head snips the first few lines off. In the showroom you'd click through folders for a minute; in the workshop you type one line and you're done.
The workshop's superpower is the conveyor belt: the pipe symbol | feeds one tool's output straight into the next. "Take this log, keep only the ERROR lines, count them" is cat log | grep ERROR | wc -l — three small tools snapped together into a machine nobody had to build in advance. That composability is why, fifty years on, this is still how professionals drive computers. Every cloud server you will ever touch (Day 151) has no showroom at all — only the workshop. Today you earn your keys to it.
AI engineers live in terminals: every deploy, every docker command (Day 148), every git operation (Day 8), every SSH session into a customer's VPC (Day 170) is terminal work. Production servers have no GUI — when an FDE debugs a live incident, it's tail on a log file and grep for the error ID, under time pressure, on a machine they've never seen. Interviewers notice terminal fluency in the first five minutes of a pairing session; it reads as "has actually operated software," which is precisely the signal FDE hiring screens for. The pipes-and-filters idea also returns as Day 11's generator pipelines — same design, inside Python.
Guided practice
Navigation drill — moving without the mouse
15 min- Open a terminal (Windows users: use WSL or Git Bash for today — the commands below are the Unix set used on every server). Run pwd, then ls, then ls -la. Identify one hidden file (starts with a dot).
- cd to your ai-engineer-journey folder using tab-completion the whole way — type the first 2–3 letters of each folder and hit Tab. From now on, typing a full folder name by hand is a foul.
- Build a sandbox to destroy: mkdir -p sandbox/inner, then cd sandbox. Create files fast with: echo "hello from the workshop" > a.txt and cp a.txt b.txt. Rename with mv b.txt notes.txt. Check each step with ls.
- Practice relative paths: from inside inner/, run ls .. then cat ../a.txt then cd ../.. and pwd. Say each path out loud as a sentence ("the parent's a.txt").
- Destroy the sandbox: cd out of it, then rm -ri sandbox — answer the prompts. Note the feeling: rm has no undo, so -i (interactive) is your seatbelt while learning.
Pipes and grep — build report machines
20 min- First, manufacture a realistic log to practice on. Save the Python snippet below as make_log.py in week-01 and run it — it writes app.log with 200 timestamped lines (INFO/WARN/ERROR from a handful of fake IPs).
- Inspect without an editor: head -n 5 app.log, tail -n 5 app.log, less app.log (search inside less by typing /ERROR, n for next match, q to quit).
- Build up a pipeline one stage at a time, running after each: grep ERROR app.log — then add | wc -l to count. Then the report classic: grep ERROR app.log | sort | uniq -c | sort -rn | head -n 3 (top repeated error lines). Read it left to right as a conveyor belt.
- Save a report: grep -c ERROR app.log > report.txt, then APPEND the warning count with >>. cat report.txt to verify both lines landed.
- Two more reps: grep -v INFO app.log | head (everything except INFO), and find ~ -name "*.json" 2>/dev/null | head (where did your JSON files land this week? — the 2>/dev/null discards permission-denied noise from stderr).
Permissions, PATH & your first shell script
15 min- Run ls -l app.log and decode the permission string in a comment-line of your journal: who can read it? Write to it? Execute it?
- Explore your environment: echo $HOME, echo $PATH (note the colon-separated directories), and which python — that answer is PATH doing its job: the shell searched those directories in order.
- Set a variable and prove inheritance: export GREETING="hello from the environment", then run python -c "import os; print(os.environ['GREETING'])". This export-then-read pattern is exactly how API keys reach your code from Day 16 onward.
- Create greet.sh with the code below (nano greet.sh or use VS Code). Try ./greet.sh — permission denied. Fix it: chmod +x greet.sh, run again. That two-step (write script, make executable) is a ritual you'll repeat for years.
- Read one man page for real: man grep, find the -c flag inside it (type /-c then Enter), then quit with q.
On your own
The scavenger hunt
15 minAnswer every question below using ONLY the terminal — no editor, no file manager. Record each command and answer in scavenger.txt (build it up with >> redirection).
- How many .py files exist anywhere under your ai-engineer-journey folder?
- Which of your Python files contain the word "json" (case-insensitive), and on which line numbers?
- What are the 3 most frequent IP addresses in app.log? (Hint: ERROR lines or all lines — your choice, but the pipeline is grep/awk-free: you can cut with spaces or just sort | uniq -c the full lines from a grep for one IP at a time... or discover the cut command with man cut for style points.)
- How many TOTAL lines of Python have you written this week? (find + cat + wc, or discover xargs.)
- What is the newest file in your week-01 folder? (man ls — look for a sort-by-time flag.)
Constraints: every answer line in scavenger.txt must be appended with >>, never >. If you wipe the file, that's the Day 5 lesson billing you twice.
The backup ritual
Write backup.sh, a shell script that snapshots your journey folder. It must: (1) build a timestamped folder name like backups/journey-2026-08-11 using $(date +%F); (2) create the backups directory with mkdir -p; (3) copy week-01 into it with cp -r; (4) append one line to backups/backup.log recording the date and how many files were copied (find + wc -l); (5) print a friendly done message. Make it executable, run it, verify with ls and cat. Run it again tomorrow morning — rituals only count if repeated. Keep backups/ OUT of the folder being copied (put it as a sibling), or your backups will recursively swallow themselves — reason it out before you run.
Common mistakes & misconceptions
- Running rm without thinking. There is no trash can — rm is permanent. Use rm -i while learning, and treat rm -rf as a loaded tool: read the path twice, especially with wildcards.
- Using > when you meant >>. Same trap as Day 5's "w" vs "a": one character silently wipes the file. Appending logs and reports is almost always what you want.
- Putting spaces around = in shell assignments: NAME = "x" fails; it must be NAME="x". The shell parses spaces as argument separators, not decoration.
- Believing "command not found" means the tool is missing. Often it exists but is not on PATH, or your PATH differs between terminals. which and echo $PATH diagnose it — the Day 1 two-Pythons problem was this in disguise.
- Ignoring stderr. 2>/dev/null hides errors from a pipeline — great for find's permission noise, terrible as a habit. Know which stream your output is on before you silence one.
- Editing PATH or shell config by copy-pasting internet advice without reading it. One bad line in your shell profile breaks every future terminal. Change one thing, open a new terminal, verify.
Q1. What does the pipeline "grep ERROR app.log | wc -l" print?
Q2. You create script.sh and type ./script.sh — "Permission denied". The fix?
Q3. What is PATH?
Go deeper — curated resources
- tail -f and following live logs — Start python make_log.py in one terminal modified to write slowly in a loop, and tail -f app.log in another. Watching a log grow in real time is the primal production-debugging experience — Day 142 gives it structure with tracing.
- Navigation drill done with tab-completion throughout; sandbox created and removed
- Top-3-errors pipeline built stage by stage and explained aloud
- greet.sh and backup.sh both executable and run successfully
- All five scavenger answers recorded via >> in scavenger.txt
- Quiz ≥ 2/3 (rerun the pipeline lab if you missed question 1)
← Back: The > vs >> trap is Day 5's "w" vs "a" wearing overalls, and echo $GREETING reaching Python closes the loop on Day 1's "shell and REPL are different worlds" — now you pass data between them deliberately.
Forward →: Day 8's git lives entirely in this terminal. Day 16 reads config from the environment variables you exported today; Day 39 explains what processes and file descriptors really are; Day 148's Docker containers are driven by these exact commands; and tail -f on a production log is how Day 172's customer debugging sessions actually look.
Unlocks: D8 Git — Your Time Machine · D16 Logging, Config & CLI Ergonomics · D17 Packaging & Environments · D39 Operating Systems Essentials