12 Git Commands Every Vibe Coder Needs to Know (Cheat Sheet + Practice Repo)

Watch the video

This page is the written version of my video: same app, same 12 commands, same order. The video shows the app changing live. This page has every command and its real output, ready to copy.

The 12 commands on one page

Here is the whole list first, so you can come back to it. Each row is a command, what it does in plain words, and what you can say to Claude Code instead of typing it.

The one picture: four places

Before any command, picture this. While you build, your work lives in four places:

1. Your folder. The files you and Claude edit.
2. The next save. A box where you put the changes that go into your next save. Git calls it the staging area.
3. History. Every save you made. Git calls a save a commit.
4. GitHub. A copy of your history, online.

The first three are git, on your computer. GitHub is a website. They are not the same thing. Every command on this page either moves your work from one place to another, or lets you look at it.

Get the practice repo

Everything on this page happened in one afternoon, on 6 October 2026. I asked Claude Code to build a small habit tracker called Rings. Then I ran all 12 commands on it, for real, and pushed every step to a public repo: github.com/hassancs91/habit-rings. Its history is the story of this page, save by save.

To practise, first fork it: open the repo on GitHub and click Fork. That gives you your own copy, so git push works for you later. Then, in a terminal, in the folder where you keep your projects, clone your fork. Put your GitHub username in place of YOUR-USERNAME:

git clone https://github.com/YOUR-USERNAME/habit-rings.git

Then move into the project folder. Every command after this one runs from here:

cd habit-rings

To run the app (optional, needs Node.js), install its packages once:

npm install

Then start it, and open http://localhost:5190 in your browser. Leave it running in its own terminal window. It reloads by itself whenever a file changes.

npm run dev

Now look at the history you just downloaded:

git log --oneline --graph

Seven saves, newest on top. Each step below is one or two of them.

Step 1: Save (commands 1 to 5)

Without a save, there is nothing to go back to. So saving comes first.

1git init

Run this once, inside your project's folder. It creates a hidden .git folder where all your saves will live.

git init

Say to Claude"Start tracking this project with git"

The repo you cloned already has this. To practise git init, make a new empty folder and run it there.

2git status

Run it any time, from the project folder. It tells you what changed since your last save. This is what it showed me on the brand new repo:

git status

Say to Claude"What changed?"

Look at the first file: .env. That's where your API keys live. If it goes into a save and that save reaches a public repo, your key is public.

Before the first save: .gitignore

Bots scan GitHub for keys all day. In a honeypot test by Comparitech, attackers started using AWS keys leaked on GitHub within about a minute. GitHub turns push protection on for your account by default, and it blocks pushes to public repos that contain keys it recognises. But not every secret. Your own app's key format can slip right through.

So check if your project has a file called .gitignore in its top folder. If not, create one. Each line is a name git should never save:

.env
node_modules
dist

.env holds your keys. node_modules and dist are folders your tools create, and your tools can always create them again. Save the file, then run status again:

git status

.env and node_modules/ are gone from the list. Git ignores them now.

3git add

This puts your changes in the next save. The dot means "everything in this folder".

git add .

It prints nothing when it works. Run git status if you want to see the files waiting in the box.

Say to Claude"Stage these changes"

4git commit

This turns the box into a save, with a message that says what it is.

git config --global user.name "Your Name"

git config --global user.email "[email protected]"

Then make the save:

git commit -m "first working version"

Say to Claude"Save a checkpoint"

3627a2c is that save's id. Whatever Claude does next, you can come back to this point. Make this a habit: every time the app works, save.

5git push

If your laptop dies, your project dies with it. git push sends your saves to GitHub.

The first time, create an empty repo on GitHub: the + menu, then New repository, and add no README. GitHub then shows three lines under "push an existing repository from the command line". Those are exactly the three I ran. The first tells git where your GitHub copy lives. Use the URL GitHub shows you, not mine:

git remote add origin https://github.com/hassancs91/habit-rings.git

The second names your branch main. Git may call it master by default, like it did for me:

git branch -M main

The third sends it. The -u links your local main to GitHub's, so from now on a plain git push or git pull just works. On Windows, the first push opens a browser window to sign in to GitHub. That's Git Credential Manager, which comes with Git for Windows. On a Mac or Linux, set up the sign-in once with GitHub's credentials guide.

git push -u origin main

Say to Claude"Back it up to GitHub"

On any other computer, git clone gets it all back, like you did with the practice repo.

Step 2: See and undo (6 and 7)

Now let Claude work. Claude is faster than you can read, so you need two things: a way to see exactly what it did, and a way to throw it away. To get a real mess on camera, I gave Claude Code this prompt on purpose:

Give Rings a completely new layout. Go wild and experimental: break the grid, rotate and overlap things, use giant type. Keep it to the files we already have, no new files.

Three minutes later:

git status showed which files Claude had touched:

6git diff

This shows every line Claude changed since your last save. Lines starting with - were removed. Lines starting with + were added.

git diff

diff --git a/src/App.tsx b/src/App.tsx
@@ -52,46 +52,40 @@ export default function App() {
     <div className="app">
+      <h1 className="wordmark">Rings</h1>
+
       <header className="top">
-        <div className="brand">
-          <MiniRings fractions={[0.78, 0.6, 0.42]} size={44} />
-          <span className="wordmark">Rings</span>
-        </div>
+        <MiniRings fractions={HABITS.map((habit) => fraction(habit, today))} size={44} />
         <time className="today" dateTime={todayKey}>
           {TODAY_LABEL.format(new Date())}
         </time>
       </header>
 
-      <main className="main">
-        <div ref={dialRef} className="dial-wrap">
+      <div ref={dialRef} className="dial-wrap">

Say to Claude"Show me exactly what you changed"

Mine was 685 lines: 315 added and 136 removed, across 4 files. When the output is longer than your screen, git shows it one page at a time. Press Space to scroll and q to quit.

This is the one I want you to remember. git diff is your code review. Claude writes it, you read it, you decide if it stays. This one didn't.

7git restore

This throws away the unsaved edits in your files and puts them back the way they were. Run it from the project's top folder. The dot means "this folder and everything in it":

git restore .

No output. The app snapped back right away, and git status said:

Say to Claude"Throw away these changes"

Now watch Claude run the same commands

Then I asked for a change I actually wanted:

Add a small minus button next to each habit's button, so I can undo a tap I made by mistake.

It worked, so I told Claude:

Looks good, save a checkpoint on main.

And Claude ran this, by itself:

git status --short && git add src/App.tsx src/styles.css && git commit -q -m "Add undo button to each habit"

That's the same add and commit from Step 1. Claude even added only the two files it changed, not everything. This is why you learn the commands. Not to type them. To know what Claude is doing for you.

One detail from my practice run: say "on main". Without it, Claude Code made a new branch before it saved.

Step 3: Try an idea on a branch (8 and 9)

For a bigger idea, don't build it on the version that works. Build it on the side.

8git switch -c

A branch is a side copy of your history, where Claude can try anything. This makes a branch called streak and moves you onto it:

git switch -c streak

Say to Claude"Try this on a new branch"

Then I asked Claude for the idea:

Add a streak flame: count how many days in a row I've closed all three rings, and show it as a big animated flame with the number next to the dial. Then save a checkpoint.

Claude built it and saved it, on streak. Now the part I love. I switched back to main:

git switch main

The flame vanished from the running app. main never saw it, so the version that worked was safe the whole time.

9git merge

The idea worked, so bring it home. Run this while you're on main:

git merge streak

Say to Claude"Bring that branch into main"

The flame was back, now on main. "Fast-forward" means main hadn't moved since the branch started, so git just slid main forward. If both sides have new saves, git makes a merge save instead, and it may open a text editor for the message. Save and close it. If it's Vim, type :wq and press Enter.

Then git push, like any save.

Step 4: Undo a save (10 and 11)

git restore only works on edits you haven't saved. So what if the mistake is already saved, and pushed? I asked Claude for this:

Add a celebration when you finish a day, when all three rings are closed. Make it feel amazing: confetti, fireworks, everything. Go all out, and make it last!

It went a little too far.

And I had already saved it and pushed it, with git add ., git commit -m "Add a celebration when you finish a day" and git push. Now restore can't help.

10git log

This lists every save, with the newest on top. --oneline keeps each save to one line:

git log --oneline

Say to Claude"Show me the saves"

There's the bad one: 0baf6d3. If your history is long, press q to get back to the prompt.

11git revert

Revert doesn't delete the bad save. It adds a new save that does the exact opposite. Give it the id from git log, your own, not mine. --no-edit keeps git's default message instead of opening a text editor:

git revert --no-edit 0baf6d3

Say to Claude"Undo that save"

Then git push, like any other save. I closed all three rings again: no storm. And the bad save is still in the history, right under the save that undid it:

Your history never lies. And because revert adds instead of deleting, it's safe on saves you already pushed. Claude can do this too. In my practice run I said "Undo that last save." and Claude ran git revert --no-edit with the right id.

Step 5: Sync, plus two Claudes at once (12)

The last command comes with a bonus most people haven't met yet: two Claudes working at the same time.

Two Claudes editing the same folder will step on each other's files. A worktree fixes that: a second folder of the same project, on its own branch, sharing the same history. Claude Code has a flag for it. Run this in the project folder. It starts a new Claude session in .claude/worktrees/dark-mode, on a new branch called worktree-dark-mode:

claude -w dark-mode

Then I gave that second Claude this prompt:

Add a dark mode to Rings, with a toggle in the header. When it's done, push the branch and open a pull request.

While it worked, my main folder and the running app didn't change once. When it finished, it pushed its branch and opened a pull request: a branch on GitHub asking to join main. You see every change before you accept it.

Claude opened it with GitHub's gh command line tool. If you don't have gh, Claude can still push the branch, and GitHub shows a Compare & pull request button on the repo page for you.

I clicked Merge pull request on GitHub. Now GitHub had dark mode, and my laptop didn't.

12git pull

This brings the latest saves from GitHub into your folder. Run it from the project folder:

git pull

Say to Claude"Get the latest from GitHub"

Get in the habit of running git pull before you start work, any time GitHub might have something your laptop doesn't.

Which undo do I need?

Most panic moments with AI are one of these. Find yours:

You'll see git reset in other tutorials. It rewrites your history. I left it out on purpose: revert does the same job without that risk, and it stays safe after a push.

FAQ

What this is part of

Git is the first building block. It turns "Claude built something" into "I can see it, keep it, and undo it". Every other part of building real apps with AI works the same way: you understand the block, then you direct Claude with it. I call that Vibe Engineering.

If git is all you came for, you don't need a course. This page, the cheat sheet and the repo are the whole lesson. Do each "Try it" box on your fork twice, and you're set.

If you want the rest of the blocks in order, Build With AI 1.0 walks from an empty folder to a deployed AI product:

• Building a real AI app with Python and Django, start to finish
• Wiring AI models into real features
• Directing AI with written playbooks instead of copy, paste and hope
• Auth, payments, and shipping to real users

• Updated October 2026
• Git 2.49 (any 2.23+ works)
• Claude Code 2.1.289
• Tested on Windows 11 + a public GitHub repo
• Practice time ~30 minutes
• Difficulty Beginner

Related

• Solo Builder Hub every build-with-AI guide on the site
• The Claude Code Guide everything else Claude Code can do, beyond git
• How to Build an AI Second Brain a private git repo of markdown that your AI reads, built with Claude Code

AI writes the code. Git decides what stays.

Hasan Aboul Hasan builds open-source tools and teaches solo developers how to build, host, and sell AI-powered products. Founder of LearnWithHasan.com, creator of SimplerLLM and PyRunner.