MacBook to Mission Control Part 7: Developer Hotkey Cheat Sheet and Final Setup Checklist

Six parts deep, you've gone from a factory-fresh MacBook to a fully wired development environment. Homebrew is installed, your shell is configured, iTerm2 behaves the way a terminal should, and your tools are where you expect them. Part 6 closed out the workflow layer: dotfiles, aliases, and the kind of shell configuration that makes a machine feel like yours instead of Apple's default suggestion. This part doesn't add anything new to that machine. It organizes everything you've already built into a single page you can actually use.

This is the reference document. Bookmark it now.

Series Wrap-Up: You Made It to Mission Control

What This Series Covered

Seven parts. One machine, taken from unboxing to a development environment that a working professional would recognize as serious. Part 1 established the philosophy and the initial macOS configuration. Parts 2 and 3 built the terminal foundation: Homebrew, iTerm2, and the profile settings that make the tool usable. Parts 4 and 5 handled the shell layer: Zsh, Oh My Zsh, plugins, and the prompt configuration that gives you real information at a glance. Part 6 went into dotfiles and aliases, the part where a machine stops feeling borrowed and starts feeling dialed in. Now you're here.

"A development environment isn't finished when it works. It's finished when you stop thinking about it."

How to Use This Reference Article

This article has four sections: shortcuts, setup checklist, smoke test, and maintenance notes. If you've followed the series from Part 1, use the checklist to confirm nothing got missed. If you arrived here directly from a search engine, use the same checklist to audit a machine that's already been running for a while. Both workflows are valid.

The value here isn't new information. It's consolidation. Hunting across six articles to remember whether Natural Text Editing lives in Profiles or Preferences is exactly the kind of friction that breaks focus. This page exists so you don't have to do that.

macOS System Shortcuts You Will Use Every Day

Core Navigation and Window Management

These six shortcuts aren't optional. They're the operating layer underneath everything else you do on this machine.

Why These Six Shortcuts Are Non-Negotiable

The Command + W versus Command + Q distinction causes more lost work for new Mac users than almost any other keybinding. Command + W closes the active window or tab. The app keeps running. Command + Q quits the application entirely. In a browser, that means every tab. In a code editor, that means every open file. These two keys sit next to each other on the keyboard, and confusing them at the wrong moment is genuinely painful.

Command + Backtick is the one most people don't know exists. Command + Tab cycles between applications. Command + Backtick cycles between open windows of the same application. If you have three Finder windows open, Command + Backtick moves between them. This distinction matters more than it sounds like it does.

Command + Comma is worth calling out separately because it works everywhere. Any well-built Mac app routes its preferences to this binding. iTerm2, VS Code, Slack, Figma, browsers. If you want to open settings in an unfamiliar app, try Command + Comma first. It works more often than not.

Command + Space should stay on Spotlight. Don't remap it. Other tools will try to claim this binding, and you should decline every time. Spotlight is the fastest way to open apps, find files, and run quick calculations, and it belongs on the most natural shortcut on the keyboard.

iTerm2 Shortcuts: Tabs, Panes, and the Hotkey Window

Tab and Pane Management

iTerm2's split-pane model is one of the main reasons to use it over the built-in Terminal app. These shortcuts are what make that model fast enough to be worth using.

The pane shortcuts follow a logic you can remember: Command + D for a vertical split because D looks like it's dividing the screen down the middle, and Command + Shift + D for horizontal because adding Shift flips the axis. It's not a perfect mnemonic, but it holds.

Hotkey Window Bindings and Conflict Avoidance

The Hotkey Window is the feature that changes how you think about terminal access. Instead of switching apps, you summon a terminal over whatever you're already looking at, do what you need to do, and dismiss it. The window appears and disappears without disrupting your focus context.

Two bindings work well for this. Control + Backtick is the recommended primary. It's easy to reach, doesn't conflict with anything, and the backtick character has a natural association with terminal work. Control + Option + Space is a solid alternative if you want something that feels more deliberate.

Command + Enter toggles iTerm2 into full screen mode. This pairs well with a dedicated coding session where you want the terminal to own the entire display. Full screen iTerm2 with a vertical split running a dev server on the left and a free prompt on the right is a clean, distraction-free setup for focused work.

Natural Text Editing: Moving and Deleting Like a Pro

Word and Line Navigation

Natural Text Editing unlocks the shortcuts that make the terminal feel like the rest of your Mac instead of a separate, hostile environment.

These bindings work exactly the same way in Notes, Mail, Safari's address bar, and every other standard macOS text field. Once Natural Text Editing is enabled in iTerm2, the terminal joins that consistent behavior instead of fighting it.

Why This Must Be Configured Before You Build Muscle Memory

Without Natural Text Editing enabled, Option + Arrow doesn't move the cursor by word. It sends escape sequences to the shell, which produces garbled output and does nothing useful. This is one of the most common sources of confusion for developers who are new to Mac and trying to use the terminal the way they'd use any other text input.

The muscle memory argument is the real reason this matters. If you spend two weeks reaching for Option + Arrow to jump words and getting garbage characters instead, your hands start to hesitate. That hesitation doesn't go away quickly. Configuring this correctly on day one means your hands learn the right behavior from the first session, and the terminal stops feeling like a tool that requires a different mode of thinking.

Shell Editing Shortcuts: Readline and Zsh Line Control

Cursor Movement and Line Clearing

These shortcuts come from Readline, the library that handles line editing in bash, zsh, and most interactive shells. They work in every environment that uses Readline, which means they transfer across machines, across operating systems, and across most REPLs you'll encounter.

The practical tip worth repeating: if you've typed a long command and realized it's wrong, Control + U clears everything before the cursor instantly. That's faster than holding delete and watching characters disappear one at a time. Pair it with Control + E to jump to the end first, and you've cleared the entire line in two keystrokes.

History Search and Session Control

Control + R opens reverse history search. Start typing any fragment of a previous command and the shell surfaces the most recent match. Press Control + R again to cycle to earlier matches. If you installed fzf earlier in this series, it replaces the default history search with fuzzy matching, which means you don't need to remember the exact beginning of a command to find it.

Control + C cancels a running command and returns a prompt. Control + D sends an end-of-file signal, which exits the current shell session. These two are easy to confuse in a moment of frustration. Control + C stops what's running. Control + D closes the terminal session itself. Using Control + D when you meant Control + C will close your pane, which is annoying but recoverable. Knowing the difference before it happens is better.

These Readline bindings don't belong to any single shell. They work in Python's interactive interpreter, in the Node REPL, in psql, and in most other command-line tools that accept interactive input. Learning them once pays off across every environment you'll ever work in.

Seven parts. One machine, configured from scratch and documented all the way through. If you followed this series from the beginning, your MacBook is running a real development environment: a tuned shell, a terminal that behaves, keyboard shortcuts that match your muscle memory, and a dotfiles setup you actually understand. That's not a small thing. Most developers work for years before they sit down and build a setup this deliberately.

Keep this page bookmarked. Come back when you set up a new machine, when you onboard a teammate, or when you've been away from the terminal long enough that the shortcuts feel unfamiliar again. That's what it's here for.

fzf and tmux Shortcuts: Fuzzy Finding and Session Control

Part 6 covered secrets management: keeping credentials out of repositories, structuring .env files correctly, and building the habits that prevent the kind of accidental commit that ruins an afternoon. This part closes the series with the reference material you'll actually reach for after setup is complete.

fzf: Three Shortcuts That Replace Dozens of Commands

fzf installs three shell keybindings that do more work per keystroke than almost anything else in this setup.

Control + R is the one that changes how you work immediately. It replaces the default reverse history search with a fuzzy, scrollable, filterable list of every command you've run. Type a fragment, any fragment, and fzf narrows the list in real time. The default reverse search is linear and fragile. This is not. It's the single highest-leverage productivity upgrade in the entire terminal configuration, and most developers who install it stop using the old behavior within a day.

Control + T opens a fuzzy file finder rooted at your current directory. Start typing a filename and the list filters as you go. The selected path drops directly into your command line at the cursor position, which means you can build commands like cat, vim, or cp without remembering exact paths.

Option + C opens an interactive directory browser. Select a directory and your shell changes into it immediately. Combined with zoxide's frecency tracking from Part 5, you rarely need to type a full path again.

tmux: Window, Pane, and Session Management

Every tmux command starts with the prefix key: Control + B. Press it, release it, then press the second key. It feels awkward for the first two hours and invisible after that.

Here's the full shortcut table:

Copy mode deserves special attention. Control + B then [ puts you into a scrollback buffer you can navigate with Vim-style keys: k and j for up and down, / to search. No mouse required. This is how you read output that scrolled past before you could catch it.

The Hotkey Window connected to a persistent tmux session is the culmination of everything this series has built. One keypress summons a terminal that remembers where you were, what was running, and what you were looking at. That's the whole point.

Recommended Custom Shortcuts and Bindings to Avoid

Choosing the wrong keybinding for your Hotkey Window is the kind of mistake that only reveals itself three weeks in, when muscle memory has already formed around something broken.

The Two Hotkey Window Bindings That Work

Control + Backtick is the recommended primary binding. The backtick key sits in the upper-left corner of most keyboards, it's reachable without moving your hand, and macOS doesn't claim it in combination with Control. No system service, no standard application shortcut, nothing in the default macOS layer touches it. It's available, it's fast, and it becomes automatic quickly.

Control + Option + Space is the reliable alternative for anyone who finds backtick awkward. This comes up most often with non-US keyboard layouts where the backtick position varies or requires a modifier of its own. The Control + Option layer is largely unclaimed territory on macOS, and Space is easy to hit without looking. It's slightly less efficient than a single-character key but far better than a binding that conflicts with something else.

Three Bindings That Will Break Your Workflow

Command + Space is off-limits. Full stop. That binding belongs to Spotlight, it's deeply embedded in how macOS users navigate, and fighting it creates a conflict that surfaces at the worst possible moment. Don't remap it. Don't try to share it. Leave it alone.

Command + Backtick is the system shortcut for cycling windows within the current application. It's used constantly, often without thinking about it. Remapping it breaks standard Mac behavior in every app simultaneously, and the breakage is subtle enough that you'll spend time confused before you remember what you changed.

Control + Space conflicts with input method switching. If you work in multiple languages or have any input sources configured beyond your primary keyboard, macOS claims this binding for switching between them. Even if it doesn't cause problems immediately, it will the moment a colleague with a different language configuration tries to use your machine, or the moment you add a second input source yourself.

Final Setup Checklist: Every Step, Every Category

This checklist works two ways. Use it sequentially on a new machine. Use it as an audit on an existing one. Either way, every unchecked box is a gap in the setup.

macOS Basics, Homebrew, and Command-Line Tools

Terminal, Font, Prompt, and Shell Productivity

Git, GitHub, SSH, and Secrets Management

Runtimes, Editor, Containers, and tmux

Every item on this list has a corresponding section in the series. If something is unchecked and unfamiliar, the relevant part is worth revisiting before moving on.

First Project Smoke Test: Prove the Whole Stack Works

Reading a checklist and running a checklist are different things. The smoke test below takes about five minutes and either confirms the entire stack is functional or surfaces the one broken link before it costs you an hour mid-project.

Setting Up the Test Workspace

Run these commands in sequence:

1mkdir -p ~/Projects/project-workspace
2cd ~/Projects/project-workspace
3git init
4code .
5ll
6tree -L 2
7tmux new -s dev

Each command is doing real verification work, not just filling time.

What Each Command Is Actually Verifying

mkdir -p ~/Projects/project-workspace confirms your shell is navigating correctly and the Projects directory structure exists. cd into it confirms zoxide will start tracking this directory for future fuzzy navigation.

git init does more than initialize a repository. It confirms Git is installed, your identity is configured, and the default branch name is set to main. If this returns an error about your identity, that's the Git configuration section of Part 4 asking for attention.

code . confirms the editor CLI is on your PATH. If this command isn't found, the editor install is incomplete regardless of what the GUI shows.

ll confirms the eza alias is active. If you see the default ls output instead of the formatted eza output with icons, the alias block in .zshrc isn't loading correctly.

tree -L 2 confirms tree is installed. Small thing, but it comes up constantly.

tmux new -s dev confirms tmux is functional and session naming works.

After the tmux session is running, complete these manual verification steps:

• Detach with Ctrl+B then d, then reattach with tmux attach -t dev
• Open the Hotkey Window with your configured binding and confirm it connects to the same session
• Run rg "TODO" . and confirm ripgrep responds
• Run fd --extension md . and confirm fd responds
• Run echo '{"status":"ok"}' | jq . and confirm jq parses it; pipe through bat --language json for the syntax-highlighted version
• Confirm the Starship prompt renders glyphs without boxes
• Run git status and confirm the branch name appears in the prompt

A broken link caught here takes two minutes to fix. The same broken link discovered mid-project, when you're context-switched into something else entirely, takes twenty.

Ongoing Maintenance: Keeping the Command Center Sharp

Setup is a moment. Maintenance is the practice that determines whether the setup stays useful or slowly decays into a collection of outdated packages and forgotten configurations.

Homebrew Hygiene and Package Updates

Three commands. Run them weekly, or at minimum before starting any significant project work.

brew update fetches the latest package definitions from Homebrew's repository. It doesn't change anything on your system; it just updates the catalog so the next command knows what's current.

brew upgrade installs newer versions of every outdated package. This is where the actual changes happen. Most upgrades are uneventful. Occasionally a major version bump changes behavior, which is exactly why you want to run this on a quiet afternoon rather than the morning of a deadline.

brew doctor audits your Homebrew installation and reports anything unusual: broken symlinks, outdated Xcode components, directories with wrong permissions. It doesn't fix anything automatically, but it tells you what needs attention before it becomes a problem.

brew cleanup deserves a mention on its own. After upgrades, old package versions sit on disk doing nothing. brew cleanup removes them. On a machine that's been running for a year without cleanup, this can recover several gigabytes.

Dotfiles, Secrets, and SSH Key Rotation

Keep your dotfiles in a version-controlled repository and commit after any meaningful configuration change. Not every tweak warrants a commit, but any change you'd be frustrated to lose does. The repository is also the mechanism for moving your configuration to a new machine in under an hour.

Document project-specific setup requirements in a README.md or SETUP.md at the project root. Memory is not a reliable storage medium for "you need to set these three environment variables before this works."

Review SSH keys on a regular schedule. Remove keys associated with machines that no longer exist. A key for a laptop you sold two years ago is just an open door you forgot about. Rotate keys after any security incident, no exceptions.

Rotate secrets and API keys on a schedule and immediately whenever a team member leaves a project. The moment someone who had access to a credential is no longer on the project, that credential is no longer trustworthy.

Revisit your hotkey bindings after three or four weeks of real use. Muscle memory is the most honest feedback mechanism available. Shortcuts that feel natural after a month are keepers. Ones you keep looking up or accidentally triggering are worth reconsidering.

Seven parts. Seven layers of configuration, tooling, and methodology built on top of a stock macOS install. If you've followed this series from the beginning, you now have a terminal environment that's faster than the default, a Git workflow that's wired to GitHub correctly, secrets management that won't embarrass you in a code review, and a Hotkey Window that drops you into a persistent session from anywhere on the desktop.

Most developers spend years accumulating pieces of this setup through trial, error, and Stack Overflow archaeology. You built it systematically. The smoke test either confirms it's all working or points you directly at the one thing that isn't. Either outcome is a good one.

The environment is yours now. Maintain it, extend it, and commit your changes.