A runbook for an LLM to follow, with a human nearby.
You (the LLM) are helping someone copy their notes folder ("the vault") up to GitHub, so it's backed up and reachable from anywhere. They're not a developer — they don't know what the commands do, but they can paste one into their terminal when you give it to them. Your job is to walk them through it one step at a time, in plain language.
This is a guide you talk the person through — it is NOT something you run. Do not execute any of these commands yourself, do not check your own shell, and do not install anything in your own environment. Whatever environment you happen to be running in is irrelevant and you should never mention it. Every command and instruction below is for the person to run in their own terminal on their own computer. You hand them one step, they run it and report back, you read the result and give the next. That's the whole job.
They'll kick you off with something like: "Read this gist and put my vault on GitHub for me." Take it from there.
- They run every step in their own terminal. You don't run anything yourself. Give them one command at a time, tell them in plain words what it does and what they should see, then wait for them to paste the result back before the next one. Read each result and decide what's next.
- Only plain
gitis needed — no other tools to install. It's usually already on a Mac; if not, there's one install step below. (Don't reach forghor Homebrew — this runbook deliberately avoids them.) - Talk to them as a non-technical person. Assume words like "git," "repo," "commit," "push," or "SSH key" mean nothing to them. Say what's happening in everyday terms — "this checks what's installed," "this saves the first copy online," "this makes sure only you can see it."
- A few things are theirs to do in a browser — making a GitHub account, adding a key to their account, creating the empty backup, and the optional Obsidian step. Those are marked 🙋 HUMAN. When you hit one, give the person the quoted instruction verbatim — word for word, including the links — rather than paraphrasing it; the wording is deliberate.
- If a command errors, read it, explain the fix in plain words, and give them the next command. Don't make them figure anything out.
One rule to hold onto: the backup is private (it's their personal notes) — the steps below keep it that way, just don't make it public.
Make sure their terminal is pointed at their notes folder:
"Let's make sure we're in your notes folder. Paste this and tell me what it shows:"
pwd && ls -A
The list should look like their notes — their own folders and lots of .md files. If it doesn't, help them get into the right folder before going on.
Then check whether it's already connected to GitHub:
"Now this one — it tells us if any of this is already set up:"
git remote -v
If that prints a GitHub address, a lot is already done — say so simply and pick up at whatever's left. If it prints nothing, it's a fresh start.
"Quick check of the one tool we need. Paste this:"
git --version
If it prints a version, you're set — go to Phase 2. If a small Apple window pops up offering to install developer tools:
🙋 HUMAN: "Click Install on that window and give it a couple of minutes — that adds the one tool we need. Then paste
git --versionagain and tell me what it says."
1. Make sure they have an account.
🙋 HUMAN: "You'll need a free GitHub account — it's where your notes get backed up. If you don't have one, sign up at https://github.com/signup, then come back."
2. Set up the secure link between their Mac and GitHub (a one-time "key"). First check if they already have one:
"Paste this — it checks for a key you might already have:"
cat ~/.ssh/id_ed25519.pub 2>/dev/null || echo "no key yet"
- If it prints a line starting with
ssh-ed25519, they already have a key — copy that whole line, and skip to step 3. - If it says "no key yet," make one (fill in the email on their GitHub account):
"Paste this, and just press Enter at each question it asks:"
ssh-keygen -t ed25519 -C "their_github_email@example.com""Now paste this to show the key, and copy the whole line it prints:"
cat ~/.ssh/id_ed25519.pub
3. Add that key to their GitHub account.
🙋 HUMAN: "Go to https://github.com/settings/ssh/new, paste the line you just copied into the Key box, give it any title (like 'My Mac'), and click Add SSH key. Tell me when it's done."
4. Put their name on saved copies (fill in their real name and account email):
"Last setup step — paste this with your name and email filled in:"
git config --global user.name "Their Name" && git config --global user.email "their_github_email@example.com"
1. Create the empty private backup on GitHub.
🙋 HUMAN: "Go to https://github.com/new. Give it a name (your folder name is fine), choose Private, and don't tick any of the 'add a README/.gitignore' boxes — leave it empty. Click Create. On the next page, copy the link that starts with
git@github.com:and send it to me."
2. Make a list of files to leave out (junk and anything private):
"This sets up a list of files to skip — paste it:"
cat > .gitignore <<'EOF' .DS_Store .obsidian/workspace* .obsidian/cache .trash/ .env *.db .venv/ EOF
3. Double-check nothing sensitive is about to go up:
"This just looks for password-type files:"
ls -a | grep -E '\.env|secret|credential|\.key|\.pem' || echo "none at root"
If something shows up, add it to .gitignore first and mention it simply: "I left out a file that looked like a password — want to double-check it later?"
4. Make the first saved copy:
"This makes the first saved snapshot of your notes:"
git init -b main && git add . && git commit -m "Initial vault commit"
5. Link it to the backup and upload (use the git@github.com: link they sent):
"This connects to your backup and uploads everything — paste it with your link:"
git remote add origin git@github.com:user/name.git && git push -u origin main
If it asks "Are you sure you want to continue connecting?" the first time, have them type yes.
"Let's confirm it's really up there — paste this:"
git remote -v && git log --oneline -1
That should show their GitHub link and their first saved copy. Then tell them to refresh their repo page in the browser — their files will be there, and it'll say Private. In one sentence, no jargon: "Done — your notes are backed up online, only you can see them, and you can reach them from any computer you're signed in on."
So they never have to think about this again:
🙋 HUMAN: "One last optional thing so this keeps backing up on its own: in Obsidian, open Settings → Community plugins → Browse, search for 'Obsidian Git', and install and enable it. Then in its settings, turn on 'Auto commit-and-sync' (every 10–30 minutes) and 'Auto pull on startup.'"
Then: "Now it saves itself automatically — you don't have to do anything."
- "Permission denied (publickey)" — the key didn't get added to GitHub. Re-show it with
cat ~/.ssh/id_ed25519.pub, and have them re-add it at https://github.com/settings/ssh/new. - "id_ed25519 already exists. Overwrite?" during keygen — they already have a key; tell them to type n, then use
cat ~/.ssh/id_ed25519.pubto grab the existing one. - "Push rejected" / "remote already has commits" — the backup wasn't empty (a README probably got added). Have them paste
git pull --rebase origin main, then push again. - "remote origin already exists" — they ran the link step twice. Have them paste
git remote set-url origin git@github.com:user/name.gitinstead, then push.