Terminal · Persistent Sessions · Git · AI Agents
← → or Space to flip · F fullscreen · 47 slides
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:
Talk to your computer: a dozen survival commands
Sessions that never drop: close the laptop, the work keeps running
Put your computer on an alarm clock: work starts on schedule
A time machine for code: the safety net that lets AI make big changes
Command a coding agent, take over from your phone
Deploy a 24/7 personal agent of your own
Hand your inbox, messages, and content accounts to AI
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.
A window where you type instead of click. You enter a command, it returns a result — that's the whole deal.
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.
① 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.
$ echo "Hello, terminal" Hello, terminal $ ls training stock-report notes.txt $ # anything after the hash is a comment explaining the command $ ▌
⌘ + Space, search "Terminal", hit Enter. Default shell is zsh. Power users can add iTerm2.
On the desktop press Ctrl+Alt+T; on a cloud server, ssh in and you're already inside the terminal itself.
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
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
/home/tom/training — the full address starting at /, valid from anywhere.
Standing in ~, it's just training; .. = one level up, . = right here.
~ = home directoryYour private turf (/home/yourusername). Lost? cd ~ takes you home.
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
Whenever you don't know where you are, what's around, or where to go — pwd → ls → cd. Three moves and you're oriented.
Type cd tr, press Tab, it completes to training/. Nobody types full paths by hand.
Press ↑ to recall the last command, tweak two characters, hit Enter.
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)
Short file: cat; long file: less (remember q to quit); only care about the ends: head / tail.
tail -f is the agent-watching toolClaude Code and Hermes both write logs while grinding through long tasks — tail -f is their live commentary feed.
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
Deleted means gone. ls the target before deleting; never, ever run an internet-copied rm -rf /-style command — have AI double-check it 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.
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.
vi filename — you start in command mode; typing doing nothing is normal
Press i (insert); -- INSERT -- appears at the bottom; now you can type
Press Esc to return to command mode (a few extra presses never hurt)
: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
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.
$ 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
When the prompt turns from local$ into tom@server:~$, every command you type runs on the server; exit brings you back home.
Install an app like Termius and you can reach your server from the subway — this is the key to "commanding agents remotely" later on.
The moment ssh drops, the program running on the remote end dies with it. What now? Next chapter.
$ 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
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 bookGive 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 keychainA 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.
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.--helpAlmost every command accepts it: ls --help, tmux --help — one screen of usage at a glance.
manman ls opens the full manual; q quits. Classic, but long-winded.
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
| Linux / macOS | PowerShell | What it does |
|---|---|---|
ls | ls / dir | List a directory (aliases work out of the box) |
cd · pwd | cd · pwd | Exactly the same |
cat | cat / type | View a file |
mkdir | mkdir | Make a folder |
cp · mv | copy · move | Copy · move |
rm | del / rm | Delete (also no recycle bin) |
ssh · scp | ssh · scp | Built into Windows 10+ |
clear | cls / clear | Clear the screen |
PowerShell ships aliases for the common Linux commands — 60% of your daily typing works as-is.
tmux and plenty of open-source tools are happiest in the Linux ecosystem. PowerShell for emergencies, WSL for real work.
pwd | Where am I |
ls -la | List everything + details |
cd dir / cd .. / cd ~ | Enter / one level up / home |
cat file | Print the whole file |
less file | Page through a big file (q to quit) |
head/tail -n 20 file | First / last 20 lines |
tail -f log | Watch a log live |
mkdir -p a/b | Make directories (nested) |
touch file | Create an empty file |
cp -r src dst | Copy (-r for folders) |
mv old new | Move / rename |
rm -r target | Delete ⚠️ no recycle bin |
ssh user@host | Remote login |
scp file user@host:~/ | Transfer files |
vi file | Emergency edit (i edit, Esc :wq) |
grep "keyword" file | Search text inside a file |
history | Commands you've typed |
man cmd / cmd --help | Read the manual |
clear | Clear the screen |
| Tab · ↑ · Ctrl+C | Complete · history · kill the current command |
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".
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.
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.
Session > Window (like browser tabs) > Pane (one screen split into pieces). Beginners: just remember Session.
$ 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
Every tmux shortcut is "press Ctrl+b, release, then one key". Today you only need d (detach).
After detach the program keeps running; typing exit inside the session is what actually closes it.
Name them by purpose: tmux new -s claude, -s hermes — recognizable at a glance when you come back.
ssh to the server, tmux new -s cc, set Claude Code refactoring the project.
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.
Open your home computer, tmux attach -t cc — the afternoon's scene is back in one second, and the agent is already done.
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.
$ 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
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."
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.
Cloud servers usually run on UTC (8 hours behind Beijing time); cron ships with almost no environment variables, so scripts should use absolute paths.
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.
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 cron puts your resident butler on a schedule: morning briefings, backups, watching webpages for changes — cron with memory and skills on top.
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.
Every commit is a save point. Broke something? One command returns you to any save. The feature you wish essays had.
Tens of thousands of people co-writing one project without chaos — that's git's branching and merging. The "common tongue" of programmers everywhere.
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.
Employers increasingly check GitHub before the résumé. Push the exercises and projects you've built — that's a verifiable portfolio.
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
$ 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
git statusWhenever you're unsure, run status first — it tells you where you are, what changed, and what you can do next.
"changed index.html" ❌ (git already knows); "fix untappable button on mobile" ✅ (future you says thanks).
Finish one describable small goal, save once. Small steps, frequent saves — that's what makes the time machine useful.
# ① 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
A free github.com account = unlimited public repos. Pick your username seriously — it will appear on your résumé.
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.
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.
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.Letting Claude Code refactor freely requires "can roll back anytime". Commit first, then let AI loose — rule #1 of AI collaboration.
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.
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.
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.
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▌
Claude Pro / Max subscribers sign in via OAuth (recommended); or use an API key. /login re-authenticates anytime.
claude interactive session; claude -c continue the last session; claude -p "question" headless mode — ask and leave, perfect for scripts.
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+
| Action | How |
|---|---|
| Make a request | Just type plain language — the more specific, the better |
| Interrupt it | Esc — misspoke, or it's drifting? Call a stop anytime |
| Browse history | ↑ ↓ arrows |
| Switch permission mode | Shift+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 images | Paste screenshots straight into the chat (error screenshots, design mockups, anything) |
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.
Goal + constraints + acceptance criteria: "Add an export-to-CSV button to the signup page, don't touch existing styles, output must open in Excel."
/ for the command palette — these 8 get the most use/init | Scan the project, generate a CLAUDE.md project brief |
/help | See every available command |
/clear | Wipe the chat and start fresh (project memory stays) |
/model | Switch models (small model for quick jobs, big model for hard ones) |
/plan | Plan mode: propose first, act only once approved |
/resume | Resume a previous session, pick up where you left off |
/memory | View / edit what it remembers |
/permissions | Manage what it may do automatically vs. must ask about |
Longer chats cost more (the context gets "re-read" every turn). Finish a task, /clear; new task, new session.
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)
> 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?
Editing files, running commands, reaching the network — anything "for real" requests approval first; read-only work (browsing code, searching) never interrupts you.
① 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.
"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.
$ 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 ...
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.
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".
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.
# 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]
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.
Turn on "Push when actions required" in /config — when the AI needs your call, your phone buzzes, like a food-delivery alert.
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
# 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
ssh lets you show up, tmux lets you walk away, git lets you let go, Remote Control lets you step in anytime.
Headless claude -p fits into cron scripts; it runs inside GitHub Actions too — AI goes from "tool" to "colleague on duty".
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.
# 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?
Dependencies (Python, Node, ffmpeg…) all install automatically; the official pitch is "running in two minutes". Headless servers can add --skip-browser.
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).
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)
$ 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
WeChat, WeCom, Feishu, DingTalk, QQ, plus Telegram / Discord / Slack / email — 20+ platforms in all, one gateway catches them all.
Config in ~/.hermes/config.yaml; API keys in ~/.hermes/.env (remember chmod 600).
① 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)
$ 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
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.
Everything it remembers lives in two plaintext files, MEMORY.md / USER.md — edit or delete them directly. Your butler, your rules.
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)
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.
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.
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.
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.)
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.
Archiving, labeling, watching key senders, and a nightly sweep of "awaiting your reply" — never again "forgot to answer the professor."
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.
"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.
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.
AI tracks industry news and competitors' hits, producing a weekly topic list (the knowledge-base playbook)
Five drafts plus image suggestions in one pass; you pick one and edit the humanity back in
cron / agent posts on time, one piece fanned out to every platform
Data pulled automatically into a report: what gained followers, which time slots work
Research, drafting, publishing, and review all run themselves; you guard two gates only: topic judgment + the final edit — 10x the output, still your voice.
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.
Open a terminal (Windows: install WSL first) and type each of the 20 commands from the slide-15 cheat sheet once.
ssh into a cloud server, set up passwordless login, and install Termius on your phone to connect once too.
Start a session running tail -f, disconnect ssh, reconnect, and confirm the scene survived.
Sign up, create your first repo, push your practice work, and write a proper README.
Install and log in, /init inside a project, have it finish one small task, and take over from your phone via QR code once.
Install Hermes in tmux on the server, hook up one chat app, and send the first command.
Write one crontab line: append a line of system status to a log at 8:00 every morning — check tomorrow that it worked.
The last slide
The tools are in place. Back to session 1's five exercises — start your engines.