Building tmux and nvim fluency, on purpose, for AI-coding work.

Floor questionWhat has to be true, technically, for a running program to survive you closing the terminal window that started it?

Landed: Session = the process container that survives disconnect. Window = a full-screen switchable view, preserved untouched when unfocused. Pane = a simultaneously-visible split of one window. Rule of thumb: needs to survive and be returned to intact → new window. Needs to be seen at the same time, permanently → new pane.

Floor questionSSH'd into a remote box running a long job in tmux. Wifi drops mid-session — not a clean detach, just gone. Does tmux know you left, and does it care?

Landed: A dropped connection and a clean detach look identical to tmux — it has no concept of "the connection died," only "the attached terminal went away." Reattaching is always the same command regardless of cause, because nothing ever needed special recovery.

Floor questionRunning two AI agents at once — one per project — watching both, glancing between, sometimes copying between them. Which construct holds each agent, and why?

Landed: The lesson plan gave way to a bigger, more honest question — "I understand window and pane, not session." The real rule: pane = same task, both visible at once. Window = different task, shared blast radius is fine. Session = different enough that a crash in one must never touch the other. Conclusion: one tmux session per project, windows for sub-tasks inside it — the same isolation principle already used for code repos, applied to the terminal.

Floor questionReviewing a long AI-generated diff — line 40, then 200, then back to 55. How do you move between them without breaking flow?

Landed: Motions are direct-targeting keystrokes (jump to a line, jump to a pattern). Registers are named clipboard slots that fix the one-slot overwrite problem. Macros aren't primarily about saving keystrokes — the real value is guaranteed identical execution on every repeat, so correctness doesn't quietly degrade on repeat nine of fifteen the way manual repetition does.

Floor questionOne file calls a function; the function it's actually calling lives in another file and does something unexpected. Check the other file, then come back — without losing your place.

Landed: Split-and-load shows two files at once when you genuinely need both visible. A direct buffer swap replaces what's on screen with no split at all, for a quick look-and-return. The choice between them isn't a fixed rule — it's a judgment call.

Floor questionThe same variable name is scattered across an entire file and needs to change everywhere. Macros could do it — what's the problem, and is there something more direct?

Landed: A whole-file substitute changes every match with zero per-occurrence navigation — a fundamentally different move from a macro, which still requires walking to each match even once the edit itself is automated. A confirm-each-match variant adds a review step for anything you're not fully sure about — the same shape as reviewing a diff hunk by hunk before staging it.

Floor questionJumping to a definition, so far, has meant manually opening a file and eyeballing it. What if the editor actually understood the code's structure instead of just matching text?

Landed: A language server gives real structural understanding — jump-to-definition that's instant and correct, across files, because the tool knows what a symbol actually is. But the sharper insight: a type-checker's silence is not proof of correctness. It caught a real introduced bug instantly — but the file's actual pre-existing bug, a parameter no caller ever passed, was invisible to it the entire time. That's not a flaw in the tool; it's a different, harder problem than type-checking.

Floor questionYou run a command, then a minute later want to run something almost identical — just tweak one flag. What do you actually do?

Landed: Reverse history search (type a fragment, jump straight to the most recent match) beats counting arrow-key presses. An alias is pure text substitution — no logic, no arguments, only expands at the start of a line. A function is real code — takes arguments, chains commands — for anything an alias can't express. PATH is an ordered, colon-separated list; first match wins, silently, which is why a newer tool can quietly lose to an older one shadowing it. Config files load once, at shell startup — source reapplies changes to a live shell without starting over.

Floor questionls -la and a git-aware listing both show files in a directory. What's actually different about what the modern tool can show — and why?

Landed: One pattern, confirmed four separate times. A git-aware lister queries git per-file because it was built to; plain ls predates git entirely and has no way to ask. A gitignore-aware search tool skips node_modules/ automatically; grep has no concept of a gitignore file. A frecency-ranked directory jumper remembers what you actually use; cd has no memory at all. A structural JSON tool addresses a field by its real path; a text search tool can only pattern-match, and breaks the moment the file is minified onto one line.

Floor questionYour laptop dies tomorrow. Dotfiles get you your editor config back — but every app and package installed over time isn't tracked anywhere. Could you actually list everything, right now?

Landed: A declarative, replayable file beats a name list every time — the same lesson as Lesson 6's search/replace, in a new domain. A package manager's own dump command captures formulae, casks, and taps as real install directives, not just names. But it has a hard blind spot: anything installed through the Mac App Store is structurally invisible to it. Running the App Store's own listing tool surfaced 30 real apps a package-manager-only approach would have silently missed entirely — including apps in daily use.

Floor questionYou're in nvim editing a file and need to open a different file in a sibling directory, but you don't remember the exact filename. :e <path> has been the tool since Lesson 5 for opening files directly — what's the actual limitation when you don't know the filename?

Landed: :e <path> requires the filename already known and typed — no browsing. :Ex (:Explore) opens netrw's directory listing in the current window, and given :sp/:vsp from Lesson 5, netrw's split variants follow the same pattern: :Sex (horizontal) and :Vex (vertical). The honest final insight: netrw isn't a persistent panel — every invocation is a full buffer that replaces or splits the current view, so you see the tree or the code, never both continuously the way a real docked sidebar does.