Git and GitHub for Vibe Coders

Git has hundreds of commands. Day to day you need four, plus one for emergencies.

$ git status                    # what has changed$ git add .                     # stage everything$ git commit -m "message"       # save a snapshot$ git push                      # send it to GitHub

And the one that makes the rest safe:

$ git restore .                 # throw away uncommitted changes

A branch is a parallel copy of your project. Work on it, and main stays exactly as it was until you decide otherwise.

$ git switch -c add-dark-mode     # create and move to a branch# ... prompt, review, commit ...$ git switch main                 # back to safety$ git branch -D add-dark-mode     # delete the experiment

This changes how you can work with an AI. A large or speculative request stops being risky, because the worst case is deleting a branch. You can let an agent attempt something ambitious knowing that rejecting all of it costs one command.

git add . stages everything indiscriminately, including whatever the AI touched that you never asked about. That habit is forgivable for code you wrote yourself and already know. It is a bad one to inherit for a diff you have not read end to end.

git diff shows every change before anything is staged. Read all of it, not just the file you expected — models edit configuration, delete comments, or quietly “fix” something you never mentioned, more often than a human collaborator would.

$ git diff                      # everything unstaged, file by file$ git add -p                    # stage hunk by hunk, skip what you don't want$ git diff --staged             # confirm exactly what's about to be committed

You will read these when something breaks and you are trying to find where it came from. Write what changed and why — not what files were touched, which git already knows.

1. 1
   Weak

   “updates”, “fix”, “wip”, “changes from AI”

2. 2
   Useful

   “Fix double-counted discount when two coupons apply”

You can hand this off, and the result is usually better than what people write by hand:

Look at my staged changes and write a commit message.One short summary line, then a blank line, then a couple oflines on why the change was needed.

A pull request proposes merging your branch into main. Even working alone it is worth it, because GitHub shows you the complete diff in a readable view — which is a far better review surface than an editor as changes stream past.

1. 1

   Push your branch

   git push -u origin add-dark-mode

2. 2

   Open the PR

   GitHub prompts you, or use gh pr create.

3. 3

   Read the whole diff

   This is the review. Look for things you did not ask for as much as for bugs.

4. 4

   Merge, then delete the branch

   GitHub offers both in one click.

1. 1
   Committed something you should not have

   git reset --soft HEAD~1 undoes the commit and keeps the changes staged.

2. 2
   An AI change already merged to main turns out to be wrong

   git revert <sha> undoes it with a new commit, instead of rewriting history that others may have already pulled — the right tool once a change is shared.

3. 3
   Committed a secret

   Rotate the key. It is in the history now, and removing it from the current files does not remove it from the repo.

4. 4
   Branch is a mess

   Switch back to main and delete it. That is what branches are for.

5. 5
   Merge conflict

   Paste both versions and the conflict markers to the AI with context on what each side was doing — this is one of the things it is good at.