Version control for people who learned to code with AI. The safety net you don't know you need.
I know. Every developer in the world just winced. But hear me out.
If you learned to code with AI -- if Claude Code is your IDE and you've never touched a terminal before this year -- you do not need to understand how git works under the hood. You just need to know it exists and that Claude handles it for you.
That's it. That's the entire concept. Everything else is implementation detail that Claude manages on your behalf.
Think of it like a safety net. You don't need to know how a safety net is woven. You don't need to understand the tensile strength of nylon rope or the engineering of the support structure. You just need to know the net is there -- and that someone competent set it up.
Claude is that someone.
Mostly, yes.
When you start a new project in Claude Code, it initializes a git repository automatically. As you build, Claude makes commits -- save points -- at natural breakpoints. It writes short descriptions of what changed. It manages the version history without you asking.
You can generally trust that the versioning is happening in the background. I do.
Claude is good at making routine commits. But it doesn't always know when you consider something important enough to save. Before you try something risky, before you walk away for the night, before you deploy -- that's when you speak up and ask Claude to save a clean checkpoint. Those moments matter.
Before any risky change, tell Claude:
Let's commit everything first so we have a clean version to revert to.
That's the whole practice. One sentence. Say it before you do something you're not sure about, and you'll always have a version to fall back to if things go sideways.
You don't need to know what "commit" means technically. You don't need to know where the save file lives. You just need the habit of saying "let's save before we try this." Claude does the rest.
You'll develop an instinct for this. Until then, here are the moments that matter most:
Notice the pattern: it's always before something. Save first, then do the risky thing. That order matters.
Good news: this is almost certainly already done.
macOS has git ready to go. Open Terminal and type:
git --version
If you see a version number, you're good. If it prompts you to install command line tools, say yes and let it run. That's all you need.
If you're on Windows, you may need to install git. The easiest way: ask Claude Code to check for you. If it's not there, it'll walk you through installation. Or grab it from git-scm.com.
Once git is installed, Claude Code handles everything else. It initializes repositories, makes commits, manages branches. You don't need to configure anything.
Git saves versions locally on your computer. If you want a cloud backup -- so your code is safe even if your laptop dies -- create a free GitHub account. Then ask Claude to push your project up. It's not required, but it's a nice insurance policy. More on this in the prompts section below.
You don't need to memorize commands. You just need enough vocabulary to talk to Claude about what you want. Here are the only five words that matter:
A snapshot of your code at a specific moment. Every commit has a short description of what changed. You can have hundreds of them -- a full timeline of your project's evolution.
Like making a copy of your project to try something wild -- without touching the original. If the experiment works, you merge it back in. If it doesn't, you throw the branch away and the original is untouched.
Sends your local save points up to GitHub (or another cloud service). Think of it as backing up your game saves to the cloud. Your code exists in two places now -- your machine and the internet.
The opposite of push. Grabs the most recent version from the cloud. Useful if you work from multiple computers or if someone else is contributing to your project.
The whole reason this system exists. Something broke? Revert to the last commit where everything worked. It's the undo button for your entire project -- not just one file, but everything, all at once, back to a known-good state.
If you ever want Claude to explain what it just did in plain English:
Can you explain what just happened with git in plain English?
No shame in asking. Understanding builds over time, and Claude is a patient teacher.
Copy these. Paste them when the moment calls for it. This is your entire git practice as a vibe coder.
Let's commit everything before we make this change.
Use this before any refactor, experiment, or change you're not 100% sure about.
Something broke. Can you show me recent commits and help me revert to when it was working?
The emergency prompt. Claude will show you the timeline and help you pick the right save point to go back to.
Set up a GitHub repo for this project and push everything up so I have a cloud backup.
One-time setup. Now your code lives on your machine AND in the cloud. Belt and suspenders.
Give me a quick summary of what's changed since the last commit.
Good for when you come back to a project after a break and want to remember where you left off.
You don't need to become a git expert. Professional developers spend years mastering this tool. You don't need years. You need one habit.
The safety net is there. Claude wove it for you. All you have to do is make sure it's in place before you jump.
And here's the thing -- as you use these prompts and see Claude respond with commit messages and version histories, you'll start to understand git naturally. Not because you studied it, but because you used it. That's how most real learning works anyway.
One day you'll realize you know what a branch is because you asked Claude to make one. You'll know what a merge conflict is because you hit one and Claude walked you through it. The understanding comes from the doing, not the studying.
But you don't have to wait for that understanding to start. You can start right now, with one sentence:
"Let's commit everything first."
Git is the save system. It runs on your computer and tracks every version of your code locally. GitHub is a website where you can upload those saves to the cloud. Think of git as the camera and GitHub as the photo album you share online. You need git. GitHub is optional but nice to have as a backup.
It's really hard to permanently lose work with git -- that's the whole point. Even if you do something weird, Claude can almost always help you recover. The worst case is usually just a confusing state that Claude can untangle for you. That said, the habit of committing before risky changes makes even that unlikely.
No. Claude Code runs git commands for you. You just tell it what you want in plain English -- "save this," "go back to when it was working," "push this to GitHub." If you're curious about what happened under the hood, ask Claude to explain in plain English. But you never have to memorize a command.
It's when two versions of the same file changed in ways that git can't automatically combine. It sounds scary but it's not -- Claude will walk you through exactly which parts conflict and help you pick which version to keep. You'll probably hit one eventually. It's fine.
If something isn't clicking or you hit a wall with version control, reach out. I do personalized activation sessions where I help you get set up and building -- and expansion sessions for people who are already going and want to level up.