robots on payroll.

THE VAULT / START HERE / GUIDE + PROMPTS

GitHub for People Who Don't Code

Your app lives inside Lovable, Bolt, or Replit, and someone told you to "connect it to GitHub" without explaining why, or how, or what a repo even is. This kit is the missing explanation. You leave with GitHub set up, your builder connected, the only four moves you'll ever need (each as clicks AND as a paste-this prompt), and a recovery prompt for the day something breaks. No terminal, no jargon without a translation.

LAST VERIFIED 2026-07-09

You cannot really break it (that's the whole point)

Let's kill the fear first, because the fear is the actual blocker. GitHub is not a fragile system that experts operate and beginners destroy. It is the opposite: a system whose entire job is making your work impossible to destroy. Every version you ever save is kept, forever, and any of them can be brought back.

NOTE

Use this page as a prompt reference. Every file below is built to be handed straight to an AI. Download it, drop it into Claude, ChatGPT, Cursor, or Lovable, and say "use this as my playbook." The prompts on this page are copy-paste ready.

The scary git moments you may have heard about (merge conflicts, cryptic errors, red text) are real, but they are confusing, not destructive. Your saved versions sit safely underneath the confusion, and one prompt (bottom of this page) gets an AI to walk you out of it, one confirmed step at a time.

PAYOFF

The one-line pitch: without GitHub, a bad AI session can genuinely delete your app. With GitHub, the worst case is 10 confusing minutes. That trade is the whole kit.

A repo is a project folder with a memory

A repo (short for repository) is just a folder holding your app's files, plus a complete history of every saved version. Each save is a commit (a snapshot of the whole project with a one-line note). Sending your commits up to GitHub's servers is a push. That's 90% of the vocabulary, and the full glossary is further down.

GitHub itself is the company (owned by Microsoft, free at the tier you need) that hosts the online copy. It doesn't run your app. It remembers your app.

Why you, a non-coder, want one:

ReasonWhat it means in practice
An undo button for your whole app"It worked Tuesday, the AI broke it Wednesday, put Tuesday back." Anything ever committed can be restored.
Most tools require itHosting (Vercel, Netlify), coding agents (Claude Code, Cursor), and automations all plug into a GitHub repo, not into your Lovable account.
Your escape hatchAn app that exists only inside Lovable dies with Lovable. An app synced to GitHub is yours; any other tool or AI can pick it up and keep going.

Get connected in 15 minutes (account, Desktop, your builder)

  1. 1

    Create the account

    github.com, Sign up, free plan. Use an email you'll keep forever; the username is public. Keep your first repo Private.

  2. 2

    Install GitHub Desktop

    Free from desktop.github.com, Mac and Windows. It's the point-and-click app that does the git work so you never open a terminal. Sign in, keep the defaults.

  3. 3

    Connect your builder

    In Lovable: the GitHub button, top-right of the editor. In Bolt: the GitHub button in the top toolbar. In Replit: Tools > Git in the left sidebar. In Claude Code: just ask (prompt below). If a button moved since July 2026, look for "GitHub" or "Connect to GitHub" in the project's settings; the feature exists in all of them. Click-by-click detail for each tool is in the download below.

  4. 4

    Verify it worked

    On github.com: profile picture > Your repositories > your project. You should see your files and a commit count. That number is your app's memory, and from now on it only grows.

PROMPT: The Claude Code setup prompt (works in Cursor too)
Set up version control for this project. Initialize git if needed, create a private GitHub repo for it under my account, connect the two, and push everything. If I'm not authenticated with GitHub yet, walk me through logging in one step at a time and wait for me after each step. When you're done, tell me the repo's web address.

The only four moves you need

Git has dozens of commands. You need four moves, and you never memorize the commands, because each move exists as clicks in GitHub Desktop and as an ask-your-AI prompt. The download at the end of this section has both versions of all four; here's the shape of each, plus the prompts.

  1. 1

    SAVE (commit + push)

    Do it after every working feature and always before letting an AI attempt something big. In GitHub Desktop: type a one-line message, Commit to main, then Push origin. Message rule: what the app can do now that it couldn't before, under 10 words. "Login page works" beats "changes".

  2. 2

    UNDO (go back to a version that worked)

    You're not deleting the bad version, you're making the old good one current. In GitHub Desktop: History tab > right-click the bad commit > Revert Changes in Commit > Push. Going back further than one step? Use the prompt; the AI does multi-step undo better than clicking.

  3. 3

    BRANCH (try something risky safely)

    A branch is a parallel copy for experiments while the real app (the main branch) stays untouched. Desktop: Current Branch dropdown > New Branch, name it after the experiment. Worked? Merge it into main. Failed? Switch back to main; it never knew.

  4. 4

    SHARE (let a person or an AI see the code)

    For people: repo > Settings > Collaborators > Add people. For AIs: connect the repo in the tool (in claude.ai, look for GitHub under attachments or Settings > Connectors), then start with the tour prompt below so it actually knows your codebase before helping.

PROMPT: SAVE: the ask-your-AI version
Save my work: commit everything with a clear one-line message describing what changed since the last commit (look at the actual changes to write it), then push to GitHub. Then confirm the push succeeded and tell me the commit message you used.
PROMPT: UNDO: the ask-your-AI version
My app is broken and I want to go back to a version that worked. Show me the last 10 commits as a numbered list, each with its date and message, in plain English. I'll tell you which number was the last good one. Then restore the project to that version in the safest possible way: do not delete history, do not force anything, create an undo commit instead. Before you run each command, tell me what it does in one sentence and wait for my OK.
PROMPT: BRANCH: the ask-your-AI version
I want to try something risky: [DESCRIBE THE EXPERIMENT]. Before we start, create a new branch named after this experiment and make sure all current work is committed and pushed on main first, so main is safe no matter what. Do all the experimental work on the branch. When we're done, I'll say either "keep it" (then merge it into main and push) or "abandon it" (then take me back to main exactly as it was and delete the branch). Confirm the setup is done before touching any code.
PROMPT: SHARE: the codebase tour prompt (best first message of any help session)
I've connected you to my repository [OR: the project in this folder]. Before we do anything else, read the codebase and give me a plain-English tour: what this app does, how it's organized, the 5 most important files and what each one is for, and anything that looks fragile or half-finished. Assume I didn't write the code and don't know the vocabulary. No changes yet, just the tour.

When git gets scary: the recovery prompt

One day git will show you words like "conflict" or "detached HEAD" and the app won't run. This is the moment the fear was about, so here's the exit. If you ever committed and pushed a working version, it still exists. Paste this into an AI that can run commands on your project (Claude Code, Cursor's agent, Replit's assistant), fill the one slot, and let it drive.

PROMPT: THE "HELP, I BROKE IT" PROMPT
Something has gone wrong with git in this project and I need your help. I do not code. Treat me accordingly: plain English, no jargon without a one-line explanation, one step at a time.

Here's what happened, as best I can describe it: [WHAT YOU DID / WHAT THE AI DID / WHAT THE SCREEN SAYS. Paste any error messages in full. "I don't know, it just broke" is an acceptable answer.]

Do this, in this order:

1. DIAGNOSE FIRST, TOUCH NOTHING. Inspect the state of the repository using only read-only commands. Then explain to me, in plain English and under 10 sentences: what state my project is in, how it got there (best guess), whether any of my work is at risk of being lost, and what the last few saved versions are (dates and messages).
2. PROPOSE A PLAN. Tell me which saved version you recommend returning to and why, plus what, if anything, we would lose by doing that (for example: work done after that version that was never committed). If there is uncommitted work worth keeping, your plan must stash or back it up first, and you must tell me where the backup lives.
3. WAIT FOR MY GO-AHEAD. Do not run anything that changes state until I say yes to the plan.
4. THEN EXECUTE ONE STEP AT A TIME. Before each command: one sentence on what it does and why. After each: confirm it worked. Wait for me to say "next" between steps.

Hard rules, no exceptions:
- Never delete anything, discard changes, or force-overwrite anything without telling me first, in plain English, exactly what would be lost, and getting an explicit yes from me for that specific action.
- Prefer reversible moves over clean ones. An extra "undo commit" in the history is fine; erased history is not.
- No force push, no hard reset, no deleting branches, unless you have explained the consequence and I have said yes to that exact command.
- If at any point you are not sure what state we're in, stop and say so rather than guessing.

We are done when: the app is back to a version that worked, that version is committed and pushed to GitHub, and you have given me a two-sentence summary of what went wrong and what we did, so I can avoid it next time.

WATCH OUT

After any recovery: save immediately (commit and push, message: "Recovered to working version"). The most common cause of a scary recovery is a long gap since the last save. Commit more often and this prompt becomes something you never need.

Words you'll hear and what they mean

WordPlain English
RepoA project folder with a memory. Your app's files plus every saved version of them.
CommitOne saved snapshot of the whole project, with a one-line note about what changed. The verb too: "commit your work" = take the snapshot.
PushSend your latest commits up to GitHub's copy. Until you push, a save only exists on one machine.
BranchA parallel copy of the project for experiments. The real one is usually named main. Break a branch, main doesn't care.
MergeFold a branch's changes back into main because the experiment worked.
CloneDownload your own full copy of a repo, history included, onto a computer.
Pull requestA formal "here's a branch, review it and merge if good." Built for teams; solo, you can merge without one. You'll meet these when collaborating or when an AI opens one for you.

When you outgrow this

Next rung: the workspace-setup-kit, which gets you a real local setup (terminal included, every command copy-paste) so tools like Claude Code stop feeling like someone else's house. Far horizon: github-actions-runbooks, where GitHub stops being a memory and starts being an employee, running checks and automations on every push. You don't need either today. You needed this one.

Get the next drop

Every new Vault system ships to the list first. Twice a week, free.