Terminal & Claude Code Power User

From "what's a terminal?" to daily superpowers

You already use Claude Code every day. But there's a whole world underneath it - the terminal - that you've been using without really understanding. This course fixes that, then shows you Claude Code features you didn't know existed.

What Is a Terminal?

⌨

YOU
keyboard

→

▒

TERMINAL
text interface

→

💻

YOUR COMPUTER
files, apps, settings

A terminal is a text-based interface to your computer
Instead of clicking icons, you type commands
Every app, file, and setting on your Mac is accessible through it
Claude Code runs inside a terminal - it's how Claude talks to your machine
Think of it as a direct line to the engine room, bypassing the cockpit controls

Your Filesystem Is a Tree

                    / (root)

                    ├── Users/

                    │   └── halsarjant/

                    │       ├── Desktop/

                    │       ├── Documents/

                    │       ├── hal-ea/ ← your EA repo

                    │       │   ├── domains/

                    │       │   ├── inbox/

                    │       │   └── manifest.md

                    │       └── .claude/ ← Claude Code config

                    │           ├── settings.json

                    │           ├── skills/

                    │           ├── hooks/

                    │           └── commands/

                    ├── Applications/

                    └── System/

Everything lives in folders (directories), nested like a tree
/ is the root - the very top
~ is shorthand for your home directory (/Users/halsarjant)
Paths use forward slashes: /Users/halsarjant/hal-ea/manifest.md
Hidden files and folders start with a dot (.claude/)

pwd - Where Am I?

$ pwd
/Users/halsarjant/hal-ea

pwd = "print working directory"
Shows your current location in the filesystem tree
Every terminal session starts somewhere (usually ~)
When you're lost, pwd is your "you are here" marker
Claude Code always shows the working directory in its status

cd - Moving Around

$ cd hal-ea          # go into a folder
$ cd ..              # go up one level
$ cd ~               # go home
$ cd -               # go back to where you just were
$ cd ~/Desktop       # jump to an absolute path

cd = "change directory"
Relative paths start from where you are: cd domains/genh-ops
Absolute paths start from root: cd /Users/halsarjant/hal-ea
.. means "parent directory" - go up one level
~ means your home directory
- means "the last directory I was in" - great for toggling between two places

ls - Looking Around

$ ls
domains/  inbox/  manifest.md  learnings.md

$ ls -la
drwxr-xr-x  12 hal  staff   384 Feb 27 09:30 .
drwxr-xr-x  93 hal  staff  2976 Feb 27 09:30 ..
drwxr-xr-x   8 hal  staff   256 Feb 27 09:30 .claude
drwxr-xr-x   4 hal  staff   128 Feb 27 09:30 .git
-rw-r--r--   1 hal  staff  4521 Feb 27 09:30 manifest.md

ls = "list" - shows what's in the current directory
ls -l = long format (permissions, size, dates)
ls -a = show hidden files (starting with .)
ls -la = both - the most useful combination
Flags always start with - and can be combined

Anatomy of a Command

ls

↓

command

(verb)

-la

↓

flags

(how)

~/Desktop

↓

argument

(what)

Every terminal command follows this pattern
The command is the verb (what to do)
Flags modify the behaviour (how to do it)
Arguments are the target (what to do it to)
Flags with - are short form: -l, -a
Flags with -- are long form: --all, --long
Some commands have no flags or arguments: pwd

mkdir & touch - Creating Things

$ mkdir my-project              # create a directory
$ mkdir -p deep/nested/path     # create nested dirs
$ touch notes.md                # create an empty file
$ touch already-exists.md       # updates timestamp if exists

mkdir = "make directory"
-p flag creates parent directories too (very useful)
touch creates a new empty file or updates the timestamp of an existing one
Neither command produces output on success - silence means it worked
Most terminal commands are like this: no news is good news

cp, mv, rm - File Operations

$ cp file.md backup.md          # copy a file
$ cp -r folder/ backup-folder/  # copy a directory (-r = recursive)
$ mv old-name.md new-name.md    # rename a file
$ mv file.md ~/Desktop/         # move a file
$ rm unwanted.md                # delete a file (no bin!)
$ rm -r old-folder/             # delete a directory

cp = copy, mv = move (also renames), rm = remove
rm is permanent - there is no recycle bin
Always double-check rm commands, especially with -r
rm with both -r and -f flags is the nuclear option - deletes everything, no questions asked. Be very careful.
Claude Code will warn you before running destructive commands

cat, head, tail - Reading Files

$ cat manifest.md               # print entire file
$ head -20 manifest.md          # first 20 lines
$ tail -10 manifest.md          # last 10 lines
$ tail -f logfile.log           # follow a file (live updates)

cat = concatenate (prints file contents to terminal)
head = show the beginning of a file
tail = show the end of a file
tail -f is magic - it watches a file and shows new lines as they appear
For large files, head and tail are better than cat
Fun fact: Claude Code uses its own Read tool instead of cat for better formatting

grep - Finding Needles

$ grep "status: seed" domains/**/*.md
$ grep -r "broker" .                    # search recursively
$ grep -i "CLAUDE" settings.json        # case-insensitive
$ grep -n "hook" settings.json          # show line numbers

grep = "global regular expression print" (don't worry about the name)
Searches inside files for text patterns
-r searches recursively through directories
-i ignores case
-n shows line numbers (very useful)
Claude Code has a dedicated Grep tool - faster and better formatted

Pipes | and Redirection >

command1
produces data
|
command2
filters it
|
command3
formats it
>
output.txt
saves to file

$ ls -la | grep ".md"              # list only .md files
$ cat manifest.md | head -5        # first 5 lines of manifest
$ echo "hello" > file.txt          # write to file (overwrites)
$ echo "more" >> file.txt          # append to file
$ history | grep "git push"        # find past commands

| (pipe) sends output of one command as input to the next
> redirects output to a file (overwrites)
>> appends to a file
Pipes are the UNIX superpower - combine simple tools into powerful chains
Think of it as an assembly line: each command does one thing, passing work downstream

Your Keyboard Shortcuts

Tab - auto-completes file/folder names. Press once to complete, twice to see options.
Up arrow - cycle through previous commands
Ctrl+R - search command history (type to filter)
Ctrl+C - cancel the current command
Ctrl+L - clear the screen (same as clear)
Ctrl+A - jump to start of line
Ctrl+E - jump to end of line

These work everywhere - terminal, Claude Code, any command line tool.

Environment Variables

$ echo $HOME
/Users/halsarjant

$ echo $PATH
/usr/local/bin:/usr/bin:/bin:...

$ export MY_VAR="hello"
$ echo $MY_VAR
hello

Environment variables are named values your system stores
$HOME is your home directory, $PATH is where your system looks for commands
export sets a variable for the current session
Claude Code uses environment variables for features like CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS
You'll see these in configuration guides - now you know what they are

Process Control

$ Ctrl+C              # kill the running command
$ Ctrl+Z              # pause (suspend) the command
$ fg                  # resume the paused command
$ bg                  # resume it in the background
$ jobs                # list paused/background jobs

Ctrl+C is the emergency stop - use it when anything hangs
Ctrl+Z pauses rather than kills - useful for temporarily switching tasks
If your terminal seems frozen, try Ctrl+C first, then Ctrl+Z
jobs shows what's running or paused in the background
Claude Code uses background processes for long-running tasks

Git Basics - Your Safety Net

$ git status              # what's changed?
$ git log --oneline -5    # recent history
$ git diff                # see exact changes
$ git add file.md         # stage a file for commit
$ git commit -m "message" # save a snapshot
$ git push                # sync to GitHub

Git tracks every change to your files - nothing is ever truly lost
Claude Code uses git constantly: committing, pushing, checking status
git status is your "what's happening?" command
Every commit is a snapshot you can go back to
Your EA repo's entire history is preserved in git

Git - The Mental Model

Working
Directory

your files

git add

Staging
Area

ready to save

git commit

Local
Repo

saved locally

git push

Remote
(GitHub)

in the cloud

Think of git as a series of save points in a game
git add says "I want to include these changes in my next save"
git commit creates the save point with a description
git push uploads your saves to the cloud (GitHub)
When Claude Code commits and pushes, this is what's happening underneath
git log shows your save history - try it on the EA repo

Terminal Foundations Quiz

1. What command shows your current directory?

2. What does cd .. do?

3. What does the -a flag do in ls -la?

4. What happens when you rm a file?

5. What does the pipe | do?

6. What does git status show you?

7. What does Ctrl+C do in the terminal?

cmux - Your Terminal Superpower

Module 2

Your terminal can do much more than run one command at a time. cmux turns Ghostty into a multi-pane powerhouse with an embedded browser.

cmux - Your Terminal's Secret Weapon

cmux is a CLI tool that works with Ghostty (your terminal app)
It lets you split your terminal into multiple panes
It has a full embedded browser (like having Chrome inside your terminal)
It can send notifications and set status messages
Think of it as your terminal's Swiss Army knife
Claude Code uses cmux to open rendered markdown, run browsers, and manage multiple workstreams

Splitting Panes

$ cmux new-split right     # split right
$ cmux new-split left      # split left
$ cmux new-split up        # split above
$ cmux new-split down      # split below

original

→

original
new pane
(right)

Each split creates a new independent terminal pane
Panes get a surface ID you can reference in commands
--json flag returns the surface ID for scripting
You can split as many times as screen space allows

Your md Function Dissected

# What happens when you type: md /path/to/file.md

surface=$(cmux new-split right --json 2>&1 | awk '{print $2}')
cmux send --surface "$surface" "glow -p '/path/to/file.md'; exit"
cmux send-key --surface "$surface" Enter

cmux new-split right --json - creates a pane, returns the surface ID
awk '{print $2}' - extracts the ID from the JSON output
cmux send - types a command into that pane
glow -p - renders markdown beautifully (then exits)
The ;exit closes the pane when you quit glow
This is a real example of piping terminal tools together

Remote-Controlling Panes

# Type a command into a specific pane
$ cmux send --surface "$surface" "npm run dev"

# Press Enter in that pane
$ cmux send-key --surface "$surface" Enter

# Close a pane
$ cmux close-surface --surface "$surface"

cmux send types text into a pane (like a ghost typist)
cmux send-key sends special keys (Enter, Tab, Escape, etc.)
cmux close-surface closes a specific pane
This is how Claude Code runs things in separate panes while you work

A Browser in Your Terminal

$ cmux browser open https://example.com
$ cmux browser navigate <url> --surface <id>
$ cmux browser snapshot --interactive --surface <id>
$ cmux browser get text "h1" --surface <id>

cmux has a full Playwright-style browser built in
Open any URL, read content, fill forms, click buttons
Use CSS selectors to target elements (not ref IDs - they're unreliable)
Claude Code uses this for testing deployed sites
The browser shows as a pane in your terminal - click the globe icon in the toolbar

Browser Superpowers

# Fill a form field
$ cmux browser fill "input[name=email]" "hal@genh.co" --surface <id>

# Click a button
$ cmux browser click "button.submit" --surface <id>

# Run JavaScript
$ cmux browser eval "document.title" --surface <id>

# Get the current URL
$ cmux browser get url --surface <id>

fill types into form inputs using CSS selectors
click clicks elements
eval runs arbitrary JavaScript
get text, get html, get url read page content
CSS selectors are the reliable way to target elements
Pro tip: snapshot --interactive shows the DOM tree for finding selectors

Utility Commands

$ cmux notify "Deploy complete!"          # system notification
$ cmux set-status "Building..."           # status bar message
$ cmux list-surfaces                      # see all open panes
$ cmux focus --surface "$id"              # switch to a pane

cmux notify sends a macOS system notification - useful for long tasks
cmux set-status updates the text in Ghostty's status bar
cmux list-surfaces shows all your open panes and their IDs
These are the building blocks Claude Code uses behind the scenes
When GSD shows phase progress in the status line, it's using cmux set-status

cmux Quiz

1. What does cmux new-split right do?

2. Why use CSS selectors instead of ref IDs with cmux browser?

3. What does cmux send --surface "$id" "ls" do?

4. How do you close a cmux browser pane?

Claude Code Power User

Module 3

You use Claude Code daily. Now learn the configuration, hooks, skills, and systems that make it truly yours.

The Brain: ~/.claude/

                    ~/.claude/

                    ├── CLAUDE.md           # Global instructions for ALL projects

                    ├── settings.json      # Permissions, hooks, MCP servers

                    ├── settings.local.json  # Machine-specific overrides

                    ├── commands/           # Custom /commands

                    │   ├── brainstorm.md

                    │   ├── deploy-cloudflare.md

                    │   └── surge.md

                    ├── skills/             # Knowledge library (18 skills)

                    │   ├── claudeception/

                    │   ├── frontend-design/

                    │   ├── frontend-slides/

                    │   └── ...

                    ├── hooks/              # Event-triggered scripts

                    │   ├── session-handoff.js

                    │   ├── claudeception-activator.sh

                    │   └── gsd-statusline.js

                    ├── agents/             # Custom agent definitions

                    ├── projects/           # Per-project memory

                    └── history.jsonl       # All conversation history

This is Claude Code's home base - everything lives here
CLAUDE.md is your global personality file
settings.json is the control panel
Each subfolder serves a different purpose
You can (and should) customise all of this

CLAUDE.md - Your Instructions to Claude

# Global Instructions

## Terminal Environment
Hal uses Ghostty with cmux (not tmux).
Never use `tmux` - it's not installed.
Never try `ghostty` CLI for tab/pane management
- use `cmux`.

Every project can have a CLAUDE.md in its root
~/.claude/CLAUDE.md applies to ALL projects (global)
This is how you teach Claude about your preferences and environment
The more specific your instructions, the better Claude performs
It's loaded at the start of every conversation
Your EA repo has a detailed one covering categorisation, enrichment, and idea management
Think of it as onboarding documentation for your AI colleague

Project-Level Instructions

Global ~/.claude/CLAUDE.md - applies everywhere
Project ./CLAUDE.md - applies to that repo only
Project instructions override global ones when they conflict
Your EA repo's CLAUDE.md is ~500 lines defining how ideas are captured, enriched, and managed
A Gen H dbt project might have CLAUDE.md explaining the data model and SQL conventions
The best CLAUDE.md files are living documents - update them as you learn what works

Hooks - Claude's Event System

Hook Event Timeline

SessionStart
→
UserPromptSubmit
→
PreToolUse
→
[Tool Runs]
→
PostToolUse
→
...repeat...

Hooks are scripts that run automatically when specific events happen
They can inject context, block actions, or trigger follow-ups
Defined in settings.json under the "hooks" key
Four hook events: SessionStart, UserPromptSubmit, PreToolUse, PostToolUse
Each hook runs a shell command and can return instructions to Claude
They're the most powerful customisation feature in Claude Code

SessionStart Hooks

You have two SessionStart hooks:

1. GSD Update Checker `gsd-check-update.js`

Runs when Claude Code starts
Checks if a new version of the GSD project management system is available
Keeps your tools up to date automatically

2. Session Handoff `session-handoff.js`

Checks for a handoff file from a previous session
If found, injects that context so Claude picks up where you left off
Looks in the repo's .claude/handoff.md or project memory
After reading, deletes the file so it doesn't replay
This is how you maintain continuity across /clear boundaries

UserPromptSubmit - The Claudeception Hook

You have one UserPromptSubmit hook:

Claudeception Activator `claudeception-activator.sh`

Fires every time you send a message to Claude
It injects a reminder telling Claude to evaluate whether the session produced extractable knowledge. If the answer is yes, Claude activates the /claudeception skill to extract and save it.
This is how your skills library grows automatically
The system has generated 18 skills so far - everything from SwiftUI bug patterns to deployment workflows

PreToolUse - Safety Guards

You have two PreToolUse hooks:

1. DCG (Bash commands)

Runs before every Bash command Claude tries to execute
Acts as a safety guard for dangerous commands
Can block or modify commands before they run

2. Field Theory Permission Hook (Read/Write/Edit)

Runs before Claude reads, writes, or edits files
Controls file access permissions
Can restrict which files Claude is allowed to touch
Prevents accidental modification of protected files

PostToolUse - Context Monitor

You have one PostToolUse hook:

GSD Context Monitor `gsd-context-monitor.js`

Runs after every tool call
Monitors conversation context usage
Warns when you're approaching context limits
Helps decide when to save a handoff and start a fresh session
Prevents the frustrating "context too long" errors mid-task

The Status Line

                        $ claude

                        > Working on the EA...

                        ...

                        ⚡ GSD: hal-ea | Phase 3.2 | 65% ctx

The status line shows at the bottom of your terminal
Configured in settings.json under "statusLine"
Yours runs gsd-statusline.js which shows:
- Current project name
- Active GSD phase
- Context window usage percentage
It updates after every tool call
You can customise it to show anything - git branch, time, battery, etc.

The Handoff Chain

Session 1

                            Working on task...

                            context getting full

                            /context-handoff

                            saves to handoff.md

                            /clear

→

Session 2

                            SessionStart hook fires

                            reads handoff file

                            Picks up where left off

                            full context available

Claude Code has a context window limit (~200K tokens)
Long sessions eventually fill up
/context-handoff saves your current state to a file
/clear resets the conversation
The SessionStart hook automatically loads the handoff
You lose nothing - Claude picks up exactly where it stopped
This is why you can work on complex multi-hour tasks without losing progress

/resume - Crash Recovery

# Terminal crashed? Accidentally closed the window?

$ claude --resume          # or just: claude -r
# Picks up your last conversation exactly where it stopped

$ claude --resume --list   # see recent sessions to choose from

/resume is your safety net when things go wrong
Accidentally closed Ghostty? claude --resume brings everything back
It restores the full conversation history - nothing is lost
Different from the handoff system: /resume recovers the actual session, handoffs transfer context to a fresh session
Tip: if Claude Code seems stuck or unresponsive, close the terminal and claude --resume

Custom Commands

~/.claude/commands/
├── brainstorm.md        → /brainstorm
├── deploy-cloudflare.md → /deploy-cloudflare
├── surge.md             → /surge
├── bi-analysis.md       → /bi-analysis
├── bi-consolidate.md    → /bi-consolidate
├── funder-report.md     → /funder-report
└── gsd/                 → /gsd:*

Any .md file in ~/.claude/commands/ becomes a slash command
The filename becomes the command: deploy-cloudflare.md → /deploy-cloudflare
The markdown content is the prompt - it tells Claude exactly what to do
Subfolders create namespaces: gsd/progress.md → /gsd:progress
Commands can accept arguments: /deploy-cloudflare path/to/file.html
These are your workflow shortcuts - type the command, Claude does the rest

Skills - Your Knowledge Library

~/.claude/skills/ (18 skills)
├── claudeception/       # Self-learning system
├── frontend-design/     # UI design skill
├── frontend-slides/     # Presentation builder
├── cmux-browser-automation/
├── context-handoff/
├── paper/               # ExCo paper writer
├── bi-analysis-workflow/
├── cli-hanging-in-claude-code/
├── swiftui-*            # 4 SwiftUI bug skills
└── ...

Skills are reusable knowledge packages Claude can invoke
Each skill has a SKILL.md with detailed instructions
Claude discovers and uses them automatically when relevant
The claudeception system extracts new skills from your work sessions
Skills have grown from 0 to 18 through natural use
They're like giving Claude a reference library of your hard-won knowledge

How Skills Get Created

You work on a task

Claudeception hook fires

Claude evaluates:
"Was there non-obvious discovery here?"

YES
Extract skill → SKILL.md created

NO
Skip (most sessions)

After every task, the claudeception hook asks: "Did this produce extractable knowledge?"
If Claude had to debug something non-obvious, discover a workaround, or learn something undocumented, it extracts a skill
Example: when a Node.js CLI hung in Claude Code, the debugging session became the cli-hanging-in-claude-code skill
Skills are pattern-matched: next time Claude sees a similar problem, it knows the fix instantly
This is compound learning - your system gets smarter every week

Permissions - What Claude Can Do

"permissions": {
  "allow": [
    "Bash(git pull *)",
    "Bash(git add *)",
    "Bash(git commit *)",
    "Bash(git push *)",
    "Bash(ls *)",
    "Skill(claudeception)",
    "Skill(context-handoff)"
  ],
  "defaultMode": "default"
}

Permissions control what Claude can do without asking
"allow" list: these actions run automatically
Everything else: Claude asks for permission first
Pattern matching with *: Bash(git *) allows all git commands
You can also use settings.local.json for machine-specific overrides
Balance convenience (auto-approve common actions) with safety (confirm destructive ones)

MCP Servers - Extending Claude's Reach

// ~/.claude/.mcp.json
{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp"]
    }
  }
}

MCP = Model Context Protocol
MCP servers give Claude access to external tools and data
Your Context7 server lets Claude look up live documentation for any library
When Claude needs to check "how does React Router v7 work?", it queries Context7
MCP servers can connect to anything: databases, APIs, Notion, Slack, etc.
You also have Notion connected as an MCP server
Think of each MCP server as a specialist colleague Claude can consult

GSD - Project Management for Claude

                        /gsd:new-project
                    

Research → Roadmap → Phases

                        /gsd:plan-phase
                    

Research → Plan → Verify Plan

                        /gsd:execute-phase
                    

Execute → Atomic Commits → Verify

                        /gsd:verify-work
                    

UAT → Complete

GSD (Get Shit Done) turns Claude into a project manager
Breaks large projects into researched, planned, verified phases
Each phase gets its own plan, execution, and verification
Uses parallel agents for research and execution
Atomic commits at each step - nothing gets lost
Status line shows current phase and progress

Agent Teams - Parallel Work

Team Lead (you)

Agent 1

Design
CSS

Agent 2

Content
HTML

Agent 3

Charts
Data

Agent 4

Testing
QA

Each works independently, reports back

Claude can spawn multiple agents that work simultaneously
Each agent has its own context and tools
The lead agent coordinates and assembles results
Enabled by CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS in your settings
Used for large tasks: building presentations, research, refactoring
Like having a team of specialists instead of one generalist

How Claude Remembers

~/.claude/projects/-Users-halsarjant-hal-ea/
└── memory/
    └── MEMORY.md    # Persists across sessions

Each project gets its own memory directory
MEMORY.md is loaded at the start of every conversation
Claude writes patterns, preferences, and key findings here
Different from CLAUDE.md: memory is Claude's notes, CLAUDE.md is your instructions
Your EA project memory includes cmux browser tips and the current date
Memory is how Claude Code improves across sessions for a specific project

Claude Code Power User Quiz

1. What is CLAUDE.md for?

2. What does the claudeception hook do?

3. When does the session-handoff hook fire?

4. What is an MCP server?

5. How do custom commands work?

6. What does the GSD system do?

Daily Power User Workflows

Module 4

Putting it all together. Terminal, cmux, Claude Code, and your custom systems working as one integrated workflow.

A Power User Morning

                1. Open Ghostty               → Terminal ready

                2. cd ~/hal-ea && claude  → Start Claude Code in EA repo

                3. SessionStart hooks fire → Handoff loaded, GSD checked

                4. /review                  → Check idea corpus status

                5. /inbox                   → Process any overnight captures

                6. Status line shows context → Always know where you are

Claude Code remembers your last session automatically
Hooks handle setup - you just start working
The EA system captures ideas 24/7, you process them when ready
Voice notes from your phone become processed ideas by the time you sit down

The Stack in Action

Real example: deploying a presentation

                1. /frontend-slides        → Build a presentation

                   Claude spawns 3 agents  → Parallel build

                   Agents report back      → Assembled into one HTML file

                2. /deploy-cloudflare     → Deploy to Cloudflare

                   Security scan runs      → Checks for secrets/PII

                   Deployed to pages.dev   → Live URL generated

                3. cmux browser opens      → Test the deployment

                   Navigate all slides     → Verify everything works

                   Test on mobile viewport → Check responsiveness

                4. Claudeception evaluates  → Any new skills to extract?

Terminal + cmux + Claude Code + skills = superpowers
Each tool amplifies the others
What would take hours manually takes minutes

Try It Now - Terminal Exercises

Open a second pane (cmux new-split right) and try these:

Exercise 1: Navigate your EA repo

cd ~/hal-ea && ls -la
cd domains && ls
cd .. && pwd

Exercise 2: Search for something

grep -r "status: seed" domains/
grep -rn "broker" domains/ | head -5

Exercise 3: Check your git history

git log --oneline -10
git status
git diff --stat HEAD~1

Exercise 4: Inspect Claude Code's config

ls -la ~/.claude/
cat ~/.claude/CLAUDE.md | head -20
ls ~/.claude/skills/

Each takes under a minute. If you can do all four, you've got the fundamentals.

When Things Go Wrong

Common errors and what they mean:

Error	What it means	Fix
`command not found`	The command isn't installed or isn't in your PATH	Check spelling, or install it
`permission denied`	You don't have access to that file/folder	Check with `ls -la`, might need `chmod`
`No such file or directory`	The path is wrong	Check with `pwd` and `ls`
`fatal: not a git repository`	You're not inside a git repo	`cd` to the right folder
`Connection refused`	The service/server isn't running	Check if the dev server is up

The terminal almost always tells you what's wrong - read the error message first before trying random fixes.

Cheat Sheet

Terminal Essentials

Command	What it does
`pwd`	Where am I?
`cd path`	Go somewhere
`cd ..`	Go up one level
`ls -la`	List everything
`mkdir -p`	Create directories
`grep -r "text" .`	Search files
`cmd1 \| cmd2`	Pipe output
`Tab`	Auto-complete
`Up arrow`	Previous command

Git

Command	What it does
`git status`	What's changed?
`git log --oneline -5`	Recent commits
`git diff`	See changes
`git add && git commit`	Save a snapshot
`git push`	Sync to remote

cmux

Command	What it does
`cmux new-split right`	Split pane
`cmux browser open URL`	Open browser
`cmux notify "msg"`	Send notification

Claude Code

Command	What it does
`/commands`	List available commands
`/clear`	Reset conversation
`/context-handoff`	Save state for next session
`Ctrl+C`	Cancel current operation

Rescue

Command	What it does
`Ctrl+C`	Kill current command
`Ctrl+Z` then `fg`	Pause and resume
`claude --resume`	Recover crashed session
`/context-handoff` + `/clear`	Fresh context

Final Assessment

1. You're in /Users/hal/projects/ and want to get to /Users/hal/. What command?

2. What's the difference between > and >>?

3. You want to find all files containing "broker" in the current directory and below. Which command?

4. What makes cmux's CSS selectors more reliable than ref IDs for browser automation?

5. Where do global Claude Code instructions go?

6. What triggers the claudeception skill to extract knowledge?

7. You've been working for 2 hours and context is getting full. What's the workflow?

8. What's the relationship between commands and skills?

9. A PreToolUse hook can:

10. What does cmux send --surface "$id" "npm run dev" do?

11. You're running a long command and need to do something else quickly. What's the best approach?

12. After pushing a commit from Claude Code, you want to see what just changed. What command?

Course Complete

You made it.

You now understand the terminal foundations underneath Claude Code, how cmux extends your workspace, and the hooks, skills, commands, and systems that make Claude Code truly yours.

The best way to learn is to use it. Open Ghostty, start typing, and build the muscle memory. Every command you learn removes one more barrier between your ideas and their execution.