Basic Tools Training · Training Deck
AI Training Series · Session 2 · July 2026

Basic Tools Training

Terminal · Persistent Sessions · Git · AI Agents

← → or Space to flip · F fullscreen · 47 slides

Today's route · one chain, link by link

Why learn the terminal in 2026, of all years?

Because AI agents live in the terminal. The terminal is the cockpit from which you command AI — today's seven chapters form one tightly linked chain:

01 · Terminal

Talk to your computer: a dozen survival commands

02 · tmux

Sessions that never drop: close the laptop, the work keeps running

03 · Scheduled jobs

Put your computer on an alarm clock: work starts on schedule

04 · Git / GitHub

A time machine for code: the safety net that lets AI make big changes

05 · Claude Code

Command a coding agent, take over from your phone

06 · Hermes

Deploy a 24/7 personal agent of your own

07 · AI for daily life

Hand your inbox, messages, and content accounts to AI

This session is fully hands-on: whenever a black terminal window shows up on a slide, type along. All commands assume Linux / macOS (Windows folks: install WSL on slide 5 and everything works verbatim).
01

Terminal: Learn to Talk to Your Computer

Graphical interfaces are for "users"; the terminal is for "commanders". In a GUI you can only do what the developers pre-built; in the terminal you can issue any instruction — and AI speaks the language natively.

01 · Terminal

Terminal = a text chat box; Shell = the interpreter that gets what you mean

Terminal

A window where you type instead of click. You enter a command, it returns a result — that's the whole deal.

Shell (command interpreter)

The program doing the actual work inside the terminal: Linux usually runs bash, macOS defaults to zsh, Windows has PowerShell. Different dialects, same core grammar.

Why it's worth learning

① Precise — one command is one unambiguous instruction; ② Copy-pasteable — send it to someone and it just runs; ③ Servers have no GUI; ④ it is the native language of AI agents.

Pep talk: the terminal won't break because you typed something wrong — most mistakes just print "command not found". Type boldly.
01 · Terminal · How to open it on each platform

Three platforms, three entrances — Windows folks, just install WSL

macOS built-in

⌘ + Space, search "Terminal", hit Enter. Default shell is zsh. Power users can add iTerm2.

Linux built-in

On the desktop press Ctrl+Alt+T; on a cloud server, ssh in and you're already inside the terminal itself.

Windows use WSL

The built-in PowerShell works (comparison table on slide 13), but we strongly recommend WSL — a real Linux running inside Windows.

# Open PowerShell as Administrator, one command:
PS> wsl --install
Installing: Ubuntu ...
# After a reboot, "Ubuntu" appears in the Start menu
# Open it = you now own a full Linux terminal

Why this step pays off

With WSL installed, every command in the rest of today (tmux / git / Claude Code / Hermes) can be copied verbatim; over 95% of the world's servers run Linux — learning it is learning the lingua franca.

WSL = Windows Subsystem for Linux, an official Microsoft feature, available on Windows 10 1809+ / Windows 11

01 · Terminal · Look at the map before you walk

The file system is a tree — and you're always standing on some node

/← the root, where it all starts home/ etc/← system config tom/← your home = ~ training/ stock-report/

Absolute path: start from the root

/home/tom/training — the full address starting at /, valid from anywhere.

Relative path: start from where you stand

Standing in ~, it's just training; .. = one level up, . = right here.

Tilde ~ = home directory

Your private turf (/home/yourusername). Lost? cd ~ takes you home.

01 · Terminal · Command set 1: find your way

pwd where am I · ls what's here · cd go there

$ pwd                # print working directory — where am I
/home/tom
$ ls                 # list what's here
training  stock-report  notes.txt
$ ls -l              # -l for details (size/time/permissions)
$ ls -a              # -a to include hidden files
$ cd training        # change directory — enter a folder
$ pwd
/home/tom/training
$ cd ..              # go up one level
$ cd ~               # one hop home

The lost-person combo

Whenever you don't know where you are, what's around, or where to go — pwd → ls → cd. Three moves and you're oriented.

Tab completion = half the typing

Type cd tr, press Tab, it completes to training/. Nobody types full paths by hand.

↑ arrow = history

Press ↑ to recall the last command, tweak two characters, hit Enter.

01 · Terminal · Command set 2: reading files

cat dump it all · less page through · tail -f keep watching

$ cat notes.txt      # print the whole file (great for short ones)
Today's to-dos: install WSL, learn tmux...
$ more notes.txt     # page by page: Space for next, q to quit
$ less big.log       # more, upgraded: ↑↓ scroll, / search, q to quit
$ head -5 big.log    # just the first 5 lines
$ tail -5 big.log    # just the last 5 lines
$ tail -f agent.log  # follow new lines live (Ctrl+C to stop)

Which one?

Short file: cat; long file: less (remember q to quit); only care about the ends: head / tail.

tail -f is the agent-watching tool

Claude Code and Hermes both write logs while grinding through long tasks — tail -f is their live commentary feed.

01 · Terminal · Command set 3: make, move, delete

mkdir make · cp copy · mv move · rm delete (careful)

$ mkdir demo             # make directory — new folder
$ mkdir -p a/b/c         # -p builds all three levels at once
$ touch todo.txt         # create an empty file
$ cp todo.txt backup.txt # copy
$ cp -r demo demo2       # copying a folder needs -r
$ mv todo.txt done.txt   # move — rename and relocate in one
$ mv done.txt demo/      # move into a folder
$ rm demo/done.txt       # remove a file
$ rm -r demo2            # deleting a folder needs -r

⚠️ rm has no recycle bin tattoo it on your DNA

Deleted means gone. ls the target before deleting; never, ever run an internet-copied rm -rf /-style command — have AI double-check it first.

Habit: back up important folders first

Before surgery, cp -r project project.bak — five seconds buys you an undo. Chapter 4's git is the ultimate version of this idea.

01 · Terminal · Command set 4: vi survival guide

vi: you don't need to master it, just survive it

The scenario: you ssh into a server to change one config line, and vi is often all there is. It has an "insert" mode and a "command" mode — every ounce of beginner panic comes from not knowing which one you're in.

① Open

vi filename — you start in command mode; typing doing nothing is normal

② Start editing

Press i (insert); -- INSERT -- appears at the bottom; now you can type

③ Stop editing

Press Esc to return to command mode (a few extra presses never hurt)

④ Save / flee

:wq save and quit; :q! quit without saving — the escape hatch

$ vi config.txt
# press i → make your edits → press Esc → type :wq and Enter
$ # done, and you made it out alive

Can't memorize it? Normal.

Save these four survival moves to your phone and you're covered. Leave everyday editing to AI (next chapter's Claude Code edits files far faster than you); vi is for emergencies only.

01 · Terminal · Command set 5: ssh remote login

ssh: turn a server a thousand miles away into this very window

$ ssh tom@203.0.113.7      # username@server-address
Are you sure ...? yes        # type yes on first connect
tom@203.0.113.7's password: # type the password (nothing showing is normal)
Welcome to Ubuntu 24.04 LTS
tom@server:~$              # the prompt changed = you're on the server

# —— Passwordless login (configure once, enjoy forever) ——
$ ssh-keygen                  # generate a key pair (just keep hitting Enter)
$ ssh-copy-id tom@203.0.113.7  # deliver your public key to the server

# —— Transferring files ——
$ scp localfile tom@203.0.113.7:~/   # upload
$ scp tom@203.0.113.7:~/remotefile .  # download

Read the prompt to know where you are

When the prompt turns from local$ into tom@server:~$, every command you type runs on the server; exit brings you back home.

Your phone can ssh too

Install an app like Termius and you can reach your server from the subway — this is the key to "commanding agents remotely" later on.

Planting a hook 🪝

The moment ssh drops, the program running on the remote end dies with it. What now? Next chapter.

01 · Terminal · ssh, level 2: keys and the address book

The public key is the lock, the private key is the key, config is the address book

$ ssh-keygen -t ed25519       # generate a key pair (passphrase optional)
$ ls ~/.ssh
id_ed25519  id_ed25519.pub  config  known_hosts
#  ↑private key = the key, never share   ↑public key = the lock, share freely
$ cat ~/.ssh/id_ed25519.pub   # the public key looks like:
ssh-ed25519 AAAAC3Nza... tom@laptop
# what ssh-copy-id does = append this line to the server's
#   ~/.ssh/authorized_keys (the "locks that open this door" list)

$ cat ~/.ssh/config           # SSH's address book:
Host work
    HostName 203.0.113.7
    User tom
    IdentityFile ~/.ssh/id_ed25519
$ ssh work                    # four letters onto the server, forever after
$ ssh-add                     # passphrase on the key? the keychain remembers it

Division of labor between the pair

Public key (.pub) = the lock: installed on the server's authorized_keys door; private key = the key: stays on your machine to open it. Handing out the public key is harmless; a private key leaving your computer is like posting your house key to a group chat.

~/.ssh/config = the address book

Give every server a nickname; write down address, username and which key just once — after that ssh work, scp file work:~/ all use it. A must-have once you manage two or more servers.

ssh-add = the keychain

A passphrase makes the private key safer — but typing it on every connect? ssh-add hands the key to ssh-agent for safekeeping, so you type it once per boot; ssh-add -l shows what's hanging on the ring.

Reading authorized_keys in reverse: adding one public-key line = cutting someone a copy of your house key. So on slide 33, when Claude Code helps edit configs, any change to this file deserves your personal approval.
01 · Terminal · Command set 6: three ways to call for help

Forgetting commands isn't embarrassing — knowing how to ask is the real skill

Move 1: --help

Almost every command accepts it: ls --help, tmux --help — one screen of usage at a glance.

Move 2: man

man ls opens the full manual; q quits. Classic, but long-winded.

Move 3: ask AI the 2026 way

Paste the full error message to AI; or just state the goal: "convert every mp4 in this folder to mp3" — let it write the command, you make sure you understand it before hitting Enter.

$ claude -p "count the txt files in the current directory with one command"
ls *.txt | wc -l
The new division of labor: you describe goals + review commands; AI memorizes the syntax. The one red line: for deletions or system-level commands you don't understand, make AI explain every flag before running.
01 · Terminal · A page for Windows folks

PowerShell cheat table: you already know half of it

Linux / macOSPowerShellWhat it does
lsls / dirList a directory (aliases work out of the box)
cd · pwdcd · pwdExactly the same
catcat / typeView a file
mkdirmkdirMake a folder
cp · mvcopy · moveCopy · move
rmdel / rmDelete (also no recycle bin)
ssh · scpssh · scpBuilt into Windows 10+
clearcls / clearClear the screen

Good news

PowerShell ships aliases for the common Linux commands — 60% of your daily typing works as-is.

But still: WSL

tmux and plenty of open-source tools are happiest in the Linux ecosystem. PowerShell for emergencies, WSL for real work.

01 · Terminal · Chapter cheat sheet (screenshot it to your phone)

20-command quick reference

pwdWhere am I
ls -laList everything + details
cd dir / cd .. / cd ~Enter / one level up / home
cat filePrint the whole file
less filePage through a big file (q to quit)
head/tail -n 20 fileFirst / last 20 lines
tail -f logWatch a log live
mkdir -p a/bMake directories (nested)
touch fileCreate an empty file
cp -r src dstCopy (-r for folders)
mv old newMove / rename
rm -r targetDelete ⚠️ no recycle bin
ssh user@hostRemote login
scp file user@host:~/Transfer files
vi fileEmergency edit (i edit, Esc :wq)
grep "keyword" fileSearch text inside a file
historyCommands you've typed
man cmd / cmd --helpRead the manual
clearClear the screen
Tab · ↑ · Ctrl+CComplete · history · kill the current command
These 20 cover 90% of daily life. The other 10% — ask AI.
02

tmux: Close the Laptop, the Work Keeps Running

The hook planted last chapter: when ssh drops, the remote program dies. tmux keeps your session living on the server — a disconnect just means "not watching right now", not "start all over".

02 · tmux · Why and what

A "safe-deposit box" that keeps your session on the server

The tragedy without tmux

You ssh in and set an agent on a 3-hour task → step into an elevator, Wi-Fi drops for 3 seconds → the task dies on the spot; start from scratch.

Daily life with tmux

The task runs inside a tmux session → disconnect, shut the laptop, go home and sleep, none of it matters → next day tmux attach, everything exactly as you left it.

Three layers

Session > Window (like browser tabs) > Pane (one screen split into pieces). Beginners: just remember Session.

Cloud server (never powers off) tmux session: ai pane 1: claude (running for 6 hours) pane 2: tail -f agent.log window 2: hermes 💻 your laptop (disconnect anytime) 📱 phone ssh (take over anytime)
02 · tmux · The four survival moves

Four moves is all: new, detach, list, attach

$ sudo apt install tmux   # install (Mac: brew install tmux)
$ tmux new -s ai          # ① start a session named ai
# ...launch your long task inside...
# ② detach: press Ctrl+b, release, then d (detach)
[detached (from session ai)]
$ tmux ls                 # ③ list all sessions
ai: 1 windows (created Fri Jul  4 10:02)
$ tmux attach -t ai       # ④ reattach — scene restored, untouched

# Bonus: split panes
# Ctrl+b %  split left/right | Ctrl+b "  split top/bottom
# Ctrl+b arrow keys  move between panes

The command key Ctrl+b

Every tmux shortcut is "press Ctrl+b, release, then one key". Today you only need d (detach).

Detach ≠ close

After detach the program keeps running; typing exit inside the session is what actually closes it.

Name your sessions

Name them by purpose: tmux new -s claude, -s hermes — recognizable at a glance when you come back.

02 · tmux · The point of this chapter

tmux is the agent's dorm: once it moves in, it never clocks out

Daytime · office

ssh to the server, tmux new -s cc, set Claude Code refactoring the project.

Evening · on the subway

Ctrl+b d to detach, close the laptop. The task keeps running on the server. Want progress on your phone? Termius ssh in, tmux attach.

Late night · at home

Open your home computer, tmux attach -t cc — the afternoon's scene is back in one second, and the agent is already done.

One line: ssh gives you the power to show up; tmux gives you the freedom to walk away. Chapter 5's official Remote Control takes this experience one level higher.
03

Scheduled Jobs: Put Your Computer on an Alarm Clock

tmux solves "you leave, the program stays." cron solves "you're away, the program starts itself." Master it and your server gets a daily routine.

03 · Scheduled jobs · crontab syntax

crontab: five numbers, one timetable

$ crontab -e            # edit my job table (picks an editor first time)
# ┌─ min(0-59) ┌─ hour(0-23) ┌─ day ┌─ month ┌─ weekday(0-7)
#    │           │            │      │        │
  0    9    *    *    *   ~/backup.sh >> ~/logs/backup.log 2>&1
# ↑ run the backup at 09:00 daily, log output and errors
*/10   *    *    *    *   ~/fetch-data.sh
# ↑ fetch data every 10 minutes
  0   22    *    *    5   ~/weekly-report.sh
# ↑ generate the weekly report every Friday at 22:00
@reboot  tmux new -d -s hermes 'hermes gateway start'
# ↑ bring the butler back up whenever the server reboots
$ crontab -l            # list scheduled jobs

The five-field chant

minute · hour · day · month · weekday. * = every, */10 = every 10; commas list, dashes span. Can't remember? Ask AI: "write me a cron line for Mondays at 8 a.m."

Logging is not optional

End every line with >> logfile 2>&1 — otherwise a job that fails at 3 a.m. fails silently forever. Chapter 2's tail -f is exactly what watches it.

Two rookie traps

Cloud servers usually run on UTC (8 hours behind Beijing time); cron ships with almost no environment variables, so scripts should use absolute paths.

03 · Scheduled jobs · Where it shines

Scheduled jobs × AI: three ways to run the night shift

① A data pipeline on a timer

Fetch market data after every close, clean it, store it — Exercise 1 from Lecture 1 in its final form; then trigger the analysis script once the data lands.

② Summon Claude on schedule

Headless mode goes straight into cron: claude -p "read last night's error log, summarize in 3 bullets" — AI works on a schedule with nobody in the room.

③ Hermes' calendar

hermes cron puts your resident butler on a schedule: morning briefings, backups, watching webpages for changes — cron with memory and skills on top.

The formula: cron decides "when," the script or agent decides "what," and tmux + logs guarantee "you can find out what happened." There's a homework check-in for this one.
04

Git / GitHub: a Time Machine for Code

rm has no recycle bin, but git does — the most powerful one in the universe. It's also the collaboration protocol of programmers worldwide, and the best-looking résumé you'll ever own.

04 · Git / GitHub · Why everyone should know it

Four reasons, each more down-to-earth than the last

① Time machine the undo button

Every commit is a save point. Broke something? One command returns you to any save. The feature you wish essays had.

② Collaboration protocol worldwide

Tens of thousands of people co-writing one project without chaos — that's git's branching and merging. The "common tongue" of programmers everywhere.

③ The AI-era safety net today's focus

You dare let Claude Code slash boldly through your code because of git: every AI change is recorded, and one click rolls it back. Without git, even AI won't work with a free hand.

④ GitHub = the new résumé most practical for students

Employers increasingly check GitHub before the résumé. Push the exercises and projects you've built — that's a verifiable portfolio.

Concepts in one line: git is the version-control tool installed on your machine; GitHub is a website hosting repos in the cloud (Gitee, GitLab are its peers).
04 · Git / GitHub · Mental model

Three steps: edit → save → sync to the cloud

Working dir files you're editing Staging area changes packed to save Local repo save points v1·v2·v3… GitHub remote cloud backup + showcase git add git commit git push git pull

add = drop changes into the "to-save" basket

commit = click! — a save point, with a one-line note

push / pull = sync with the cloud: push up / pull down

04 · Git / GitHub · The daily five

A day in the life of a repo

$ git init                 # turn this folder into a git repo (once)
$ git status               # the catchphrase: what's going on right now?
modified: index.html
$ git add .                # stage all the changes
$ git commit -m "finish signup form"  # save + one line of plain words
$ git log --oneline        # view the save history
a3f9c21 finish signup form
9b2d1e0 initial version
$ git diff                 # what exactly changed this time?
$ git checkout a3f9c21 -- index.html  # the undo: restore an old version

The catchphrase: git status

Whenever you're unsure, run status first — it tells you where you are, what changed, and what you can do next.

Commit messages say "why"

"changed index.html" ❌ (git already knows); "fix untappable button on mobile" ✅ (future you says thanks).

How small is one commit?

Finish one describable small goal, save once. Small steps, frequent saves — that's what makes the time machine useful.

04 · Git / GitHub · Three things in the cloud

GitHub: backup, showcase, collaboration — one-stop shop

# ① Clone someone else's project (say, the "Lobster")
$ git clone https://github.com/openclaw/openclaw.git
Cloning into 'openclaw'...

# ② Push your own repo to the cloud (create an empty repo on GitHub first)
$ git remote add origin https://github.com/you/my-site.git
$ git push -u origin main   # first push; afterwards just git push

# ③ Continue on another computer / sync teammates' changes
$ git pull

Sign up and it's yours

A free github.com account = unlimited public repos. Pick your username seriously — it will appear on your résumé.

README.md is the storefront

The repo homepage renders the README automatically: what the project is, how to run it, screenshots. A repo only counts as a portfolio piece once the README is good.

Star = bookmark + like

Last session's 380k stars for the Lobster and 210k for Hermes — this is that star. Starring the good projects you use is also how you socialize in this world.

Bonus egg 🥚: GitHub's official CLI gh — everything the website does, done in the terminal. gh auth login once; then gh repo create my-site --public --source . --push handles "create repo + link + push" in one command, and gh pr create opens PRs. Unlock it after the three moves on the left feel natural.
04 · Git / GitHub · The point of this chapter

In the AI era, git matters more, not less

AI's safety rope

Letting Claude Code refactor freely requires "can roll back anytime". Commit first, then let AI loose — rule #1 of AI collaboration.

AI's native tongue

Claude Code already works in git: it branches, writes commit messages, opens PRs. Knowing git is how you read what it's doing — and catch it drifting off course.

Your compounding asset

Starting with today's exercises, push every piece of work to GitHub. A year from now you'll own something others can't backfill: a timestamped record of growth.

This depth of git is enough for now — branches, merges and PRs can wait until you need them; AI will teach you on the spot in ten minutes.
05

Claude Code: Your Programming Partner in the Terminal

Everything from the first four chapters converges here: you command it in the terminal, it works with commands and git, tmux lets it run all night — and now, your phone can take over.

05 · Claude Code · Install and launch

One line to install, one word — claude — to launch

# macOS / Linux / WSL:
$ curl -fsSL https://claude.ai/install.sh | bash

# Windows PowerShell (works even without WSL):
PS> irm https://claude.ai/install.ps1 | iex

# Launch: cd into your project folder, then —
$ cd my-project
$ claude
Follow the prompts to log in via your browser ✓
> tell me what this project does▌

Logging in

Claude Pro / Max subscribers sign in via OAuth (recommended); or use an API key. /login re-authenticates anytime.

Three ways to open it

claude interactive session; claude -c continue the last session; claude -p "question" headless mode — ask and leave, perfect for scripts.

First thing to do

Type /init inside your project so it generates a CLAUDE.md (slide 29 covers it in depth).

Install commands and supported platforms from official docs code.claude.com/docs (verified 2026-07): macOS 13+ / Ubuntu 20.04+ / Windows 10 1809+

05 · Claude Code · Daily core moves

Six moves cover 90% of every day

ActionHow
Make a requestJust type plain language — the more specific, the better
Interrupt itEsc — misspoke, or it's drifting? Call a stop anytime
Browse history↑ ↓ arrows
Switch permission modeShift+Tab cycles: confirm each step → auto-accept edits → plan mode
Run shell directly!ls — a leading bang bypasses the AI and just executes
Feed it imagesPaste screenshots straight into the chat (error screenshots, design mockups, anything)

Permission modes are the seatbelt

By default it asks before every dangerous action; once fluent, switch to "auto-accept edits"; want a proposal before it touches anything, use plan mode.

Anatomy of a good request

Goal + constraints + acceptance criteria: "Add an export-to-CSV button to the signup page, don't touch existing styles, output must open in Excel."

05 · Claude Code · High-frequency slash commands

Type / for the command palette — these 8 get the most use

/initScan the project, generate a CLAUDE.md project brief
/helpSee every available command
/clearWipe the chat and start fresh (project memory stays)
/modelSwitch models (small model for quick jobs, big model for hard ones)
/planPlan mode: propose first, act only once approved
/resumeResume a previous session, pick up where you left off
/memoryView / edit what it remembers
/permissionsManage what it may do automatically vs. must ask about

Money-saving tip

Longer chats cost more (the context gets "re-read" every turn). Finish a task, /clear; new task, new session.

Sessions don't get lost

Closed the terminal by accident? claude -c resumes the latest, claude --resume picks from history — save files, tmux-style.

Command list from official docs code.claude.com/docs/en/commands (verified 2026-07)

05 · Claude Code · Safety & in-session permission requests

The permission prompt isn't a nuisance — it's the intern raising a hand

> clean up the old logs I don't need
Claude wants to run:

    rm -rf ~/logs/2025/

  [y] Allow once   [a] Always allow this session   [n] Deny
# Stop — read the command before you pick. rm -rf
# deserves three extra seconds: right folder? collateral damage?

When it asks

Editing files, running commands, reaching the network — anything "for real" requests approval first; read-only work (browsing code, searching) never interrupts you.

Three rules for approving

① Understand it before you approve it — especially rm, git push, curl | bash; ② money, deletion, anything public-facing: always approve manually, one by one; ③ safe read-only commands that keep recurring can be allowlisted via /permissions to cut the noise.

⚠️ Match the mode to the setting

"Auto-accept edits" is plenty for daily coding; --dangerously-skip-permissions (skip everything) belongs only inside a container or VM — the flag's name is telling you not to.

One-line principle: treat permissions like package deliveries — read the slip before you sign. The confidence to let AI loose comes from one gate held firmly: dangerous actions always pass through your hands.
05 · Claude Code · Project memory

CLAUDE.md: the "project manual" you write for the AI

$ cat CLAUDE.md
# training — AI training slides project

## Design system (must follow when editing)
- Dark tech aesthetic, palette tokens in :root
- US = cyan-blue #56C8F5, China = warm orange #F5A340
- Font sizes must scale with the screen, no fixed px caps
- All data must be verified online and cite source + date ...

What it is

A Markdown file at the project root, read automatically at every session start. What goes in: build commands, code conventions, design rules, lessons learned the hard way.

Real example: the deck you watched

On the left is a real excerpt from session 1's slide project — because of it, any brand-new session can pick up the work, never forgetting lessons like "font sizes must scale with the screen".

Hard-won tips

Keep it short and sharp (under 200 lines works best); every time the AI repeats a mistake, add a rule — it's the shared notebook between you and the AI.

05 · Claude Code · Remote Control (official)

Start it on your computer, take over from your phone

# Option 1: enable remote for the current session (type inside it)
> /remote-control my-project
✓ Enabled · QR code shown · visible at claude.ai/code

# Option 2: launch with remote from the start
$ claude --remote-control "refactor task"

# Option 3: pure server mode (multi-device connections)
$ claude remote-control
Session URL: https://claude.ai/code/session/...
[press Space to show the QR code]

How the phone connects

The official Claude app (iOS/Android): scan the QR and take over — watch progress, send instructions, approve actions; or open the session URL in any browser.

Push notifications

Turn on "Push when actions required" in /config — when the AI needs your call, your phone buzzes, like a food-delivery alert.

The one prerequisite

The local process must stay alive (closing the terminal = session over) — which is why it and tmux are a match made in heaven: the combo, next slide.

Features and commands from official docs code.claude.com/docs/en/remote-control (verified 2026-07); message triggers via Telegram/Discord (Channels) and scheduled tasks (Routines) also available

05 · Claude Code · Final form: four chapters combined

Cloud server + tmux + Remote Control = an engineer who never clocks out

# Morning, laptop:
$ ssh tom@203.0.113.7        # ① onto the server (ch. 1)
$ tmux new -s cc               # ② open a persistent session (ch. 2)
$ cd my-project && git commit -am "checkpoint before work"  # ③ buckle the safety rope (ch. 4)
$ claude --remote-control "site redesign"  # ④ go (ch. 5)
# Ctrl+b d to detach, close the lid, out the door —

# Afternoon, phone:
📱 Notification: Claude requests approval to run tests → tap "Allow"

# Evening, home computer:
$ ssh tom@203.0.113.7 && tmux attach -t cc
✓ Redesign done, tests passing, 12 new commits in git log

This is what the first five chapters were for

ssh lets you show up, tmux lets you walk away, git lets you let go, Remote Control lets you step in anytime.

Bonus: the automation door

Headless claude -p fits into cron scripts; it runs inside GitHub Actions too — AI goes from "tool" to "colleague on duty".

06

Hermes Agent: Deploy Your Live-in Butler

Claude Code is the "programming partner"; Hermes is the "life butler" — installed on a server, on call 24/7, works whenever you text it in a chat app, and understands you better the more you use it.

06 · Hermes Agent · Install and deploy (v0.18, 2026-07)

One command to move Hermes into your server

# First, assign it a dorm (chapter 2 skills):
$ ssh tom@203.0.113.7
$ tmux new -s hermes

# Official one-liner install (Linux / macOS / WSL2):
$ curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
✓ Python · Node.js · ffmpeg and other deps installed automatically
✓ global command hermes is ready
$ hermes doctor      # checkup: is the environment healthy?

The script handles everything

Dependencies (Python, Node, ffmpeg…) all install automatically; the official pitch is "running in two minutes". Headless servers can add --skip-browser.

Platform support

macOS / Windows / Linux / WSL2 / Docker are all first-class; a Linux cloud server is exactly the officially recommended setup. Native Windows uses iex (irm …/install.ps1).

Why install it on a server

A butler is on duty 24/7 — running in tmux on a cloud server, it keeps working whether your own computer is on or off.

Commands from official docs hermes-agent.nousresearch.com/docs (verified 2026-07-04) · open-source repo github.com/nousresearch/hermes-agent (MIT)

06 · Hermes Agent · First-time setup and hookup

Three steps: attach a brain → start the gateway → connect WeChat

$ hermes setup            # ① interactive wizard: answer the questions, done
$ hermes model            # pick a "brain": 30+ model providers
  Anthropic Claude / OpenAI / DeepSeek / Qwen ...

$ hermes gateway setup    # ② configure the chat platforms to connect
$ hermes gateway start    # start the resident gateway (inside tmux!)

# ③ Send your bot its first message from your phone → add your
#    user ID to the allowlist → restart the gateway, start bossing it around

Chinese platforms supported natively

WeChat, WeCom, Feishu, DingTalk, QQ, plus Telegram / Discord / Slack / email — 20+ platforms in all, one gateway catches them all.

Where the files live

Config in ~/.hermes/config.yaml; API keys in ~/.hermes/.env (remember chmod 600).

⚠️ Three security rules — break none

① Never enable "allow everyone" (ALLOW_ALL_USERS); ② keep the default human approval for dangerous actions — don't get lazy with /yolo; ③ don't run the gateway as root.

Sources: official Quickstart / CLI Reference / Weixin integration docs / Security docs (verified 2026-07-04)

06 · Hermes Agent · Skills and memory

Watch it get smarter by the day

$ hermes --tui            # the recommended terminal UI
> /skills                 # see the skills it has learned
  ├─ tidy the Downloads folder
  ├─ back up stock-report nightly
  └─ generate the weekly report
> /usage                  # check token spend, no bill shocks

$ ls ~/.hermes/skills/    # skills = plain folders you can see and touch
$ cat ~/.hermes/memories/MEMORY.md  # its memory of you, plain markdown too
$ hermes skills           # browse/install/publish community skills
$ hermes cron             # schedule it: work every night at 11

What "self-evolving" looks like in practice

You walk it through one complex task; it writes the procedure up as a skill doc in skills/ — next time it calls the skill directly, and gets smoother with use. This is the "grows with you" from session 1.

Memory in plain sight

Everything it remembers lives in two plaintext files, MEMORY.md / USER.md — edit or delete them directly. Your butler, your rules.

Skills can be "restocked"

hermes skills install pulls in community skills (compatible with the open skills standard) — raise your butler standing on the shoulders of users worldwide.

Sources: official CLI Reference / Persistent Memory / Skills docs (verified 2026-07-04)

06 · Hermes Agent · Two agents, two jobs

One handles the code, one handles the life

Claude Code programming partner

Runs inside a project, task-based: write code, fix bugs, refactor, analyze data. Finishes a job, closes the tab, hands in its work via git.

Hermes live-in butler

Runs on a server, duty-based: scheduled tasks, tidying files, looking things up, watching messages. On call in your chat apps, with skills stacking up over time.

They don't compete — they complete each other: let Hermes mind the calendar and the chores, and keep the uninterrupted hours for you and Claude Code to do real creating. Both run in tmux, both leave a git trail — everything you learned today closes the loop right here.
07

Run Your Daily Life with AI

You've learned the tools — now point them at the real battlefield: your inbox, your messages, your content accounts. Outsource the chores to agents; take your time back.

07 · AI for daily life · Email

Make AI your email secretary

Read: the morning digest

One inbox briefing every morning: who wants you, for what, and which one is urgent — a hundred emails condensed to three lines. (Hermes supports Email natively; Gmail works via API / MCP.)

Write & reply: drafts on demand

You dictate the gist; AI drafts it in your voice straight into the Drafts folder. Routine replies — confirmations, thank-yous, reschedules — come out of templates in seconds.

Manage: auto-triage

Archiving, labeling, watching key senders, and a nightly sweep of "awaiting your reply" — never again "forgot to answer the professor."

Iron rule: AI writes only to Drafts — the Send button stays in your hand. "Public-facing" sits on the must-pass-through-a-human list from the last chapter.
07 · AI for daily life · Messages & social

In the message flood, let an agent stand watch

Group-chat digests

A Hermes already hooked into WeChat/Telegram does this for free: nightly summaries of every group, with @-mentions flagged separately — 99 idle messages distilled to 3 that matter.

The chat box as task manager

"Remind me to send my advisor the update tomorrow morning." "Nag me about the weekly report every Sunday night." One casual sentence — the agent remembers and chases you on time.

⚠️ Social red lines

Allowlist yourself only; never let AI auto-reply to your friends — efficiency can be outsourced, sincerity can't. Platforms police bot automation; crossing the line can cost the account.

The right posture: the agent does the "reading and organizing," you do the "replying and deciding" — it's a sentry on watch, not a stand-in for your social life.
07 · AI for daily life · Content & marketing accounts

One person + AI = a running content account

① Topic research

AI tracks industry news and competitors' hits, producing a weekly topic list (the knowledge-base playbook)

② Drafts in bulk

Five drafts plus image suggestions in one pass; you pick one and edit the humanity back in

③ Scheduled publishing

cron / agent posts on time, one piece fanned out to every platform

④ Weekly review

Data pulled automatically into a report: what gained followers, which time slots work

The efficiency is the pipeline

Research, drafting, publishing, and review all run themselves; you guard two gates only: topic judgment + the final edit — 10x the output, still your voice.

⚠️ Red lines & the floor

Platforms require AI-content labeling — comply; no spam marketing (sockpuppet fleets, fake engagement) — that's bans plus legal risk; authorize accounts through official APIs and never hand a password to any script.

This page is Lecture 1's "Pro Workflow" in miniature: knowledge base → production → publishing → data feedback. Get one small account running, and you've run a tiny company.
✓

Homework: seven things, checked off within a week

① Terminal warm-up

Open a terminal (Windows: install WSL first) and type each of the 20 commands from the slide-15 cheat sheet once.

② Reach a server

ssh into a cloud server, set up passwordless login, and install Termius on your phone to connect once too.

③ tmux experiment

Start a session running tail -f, disconnect ssh, reconnect, and confirm the scene survived.

④ Open a GitHub account

Sign up, create your first repo, push your practice work, and write a proper README.

⑤ First taste of Claude Code

Install and log in, /init inside a project, have it finish one small task, and take over from your phone via QR code once.

⑥ Deploy Hermes

Install Hermes in tmux on the server, hook up one chat app, and send the first command.

⑦ Set an alarm

Write one crontab line: append a line of system status to a log at 8:00 every morning — check tomorrow that it worked.

Check off all seven and you'll own: a server in your pocket, a programming partner, and a personal butler — everything the session-1 exercises require.

The last slide

The terminal is the cockpit,
and now you hold the keys.

The tools are in place. Back to session 1's five exercises — start your engines.

GitHub