Git

You already know the feeling Git gives you, because you’ve felt it in other places. It’s the feeling of pressing Undo in a writing app — that quiet safety of knowing that whatever you just did, you can take it back. Git is that feeling, made much deeper and much braver.

In an ordinary document, Undo is shallow: it remembers the last little while, and once you close the file, it forgets. Git remembers everything, forever, in named moments you choose — and it lets you not just step back one click, but return to exactly how things were last Tuesday, compare then with now, and try bold things knowing you can always come home.

Why this matters more than it sounds

Most fear around making things — websites, code, anything on a computer — is really the fear of breaking what already works. What if I change this and can’t get it back? That fear makes people timid, and timid is a poor way to learn.

Git removes that fear. Once your work is saved in Git, you are free to experiment wildly, because there is always a clean, remembered version to return to. It turns “I might ruin this” into “let me try — I can always go back.” That shift is the whole point.

And you can feel it right now, in miniature. Below is a little postcard of a project. Wreck it — change things, scramble things, even lose the picture for good. Then save a moment you like, wreck it some more, and click any saved moment to watch your work come back exactly as it was. Notice what’s missing: there is no undo button. The saved moments are the undo.

My Little Site

Change the colour Scramble the layout Lose the picture

Save this moment

Saved moments

1

Moment 1 is saved. Nothing you break now can be lost — go ahead, try the buttons.

That’s the entire emotional truth of Git. Everything below is just learning its words for what you’ve already done.

The two words that are 90% of Git

Git sounds large, but in daily use it leans on two small ideas:

• Commit — saving a snapshot. You take a picture of your work as it is right now and give it a short note (“added the homepage”). That snapshot is kept forever. A commit is one remembered moment you can always return to.
• Clone — making your own full copy of someone’s project to work with, including its entire history of snapshots.

That’s most of it. Everything else is a refinement of “take a snapshot” and “go look at the snapshots.”

It lives on your own computer — no internet required

A common confusion worth clearing up gently: Git is not GitHub. Git lives entirely on your own machine and needs no account, no website, no internet at all. You can use it alone, privately, forever, and never share a thing.

So what’s GitHub, then?

If Git is your private box of snapshots on your own desk, GitHub is an optional shared shelf on the internet where you can also keep a copy — so a teammate can see your work, or so it’s safely backed up off your machine, or so you can fetch someone else’s project.

GitHub (and its cousins, GitLab and others) is convenient and popular, but it is a choice on top of Git, never a requirement. You can do everything below with no GitHub account at all. And when you do use it, it can be private — visible only to you and the people you invite — not necessarily public to the world.

Try it: the whole everyday loop, for real

Here’s the quiet pleasure of Git — the core of daily use is just a handful of short lines, and you can run them right now on your own computer to feel how it works. Nothing here touches the internet or changes anything outside the folder you’re in.

First, in a folder with some files, you tell Git to start watching this project:

git init

Now, any time you want to see where things stand — what you’ve changed since your last snapshot — you ask:

git status

It answers in plain terms: here’s what’s new, here’s what changed. This one command is your most-used friend; it’s how you look before you leap. Run it as often as you like — it only reports, it never changes anything.

When you’re ready to save a snapshot, it’s two small steps. First you gather the changes you want to include (“stage” them), then you take the picture (“commit”) with a note:

git add .
git commit -m "My first snapshot"

That’s it — a moment of your work, remembered forever. Do that whenever you reach a point worth being able to return to. And to see the trail of every snapshot you’ve ever taken:

git log

A list of every remembered moment, newest first. That list is your safety net made visible.

What those pieces mean — staging, the message, the dot

• git add . — the dot means “all the changes in this folder.” Staging is just Git asking “which of your changes go in this snapshot?” so you can include some and leave others for later. Beginning out, “all of them” (.) is perfectly fine.
• -m "..." — the little note on the snapshot. Write it for your future self: a few words about what this moment contains. “Fixed the broken link” is a gift to you in three weeks.
• Going back — because every commit is remembered, you can always return to an earlier one. The commands for traveling between snapshots come a little later in anyone’s Git journey, but the important thing to hold now is: the moments are saved, so you can always go back.

Where this quietly becomes a superpower: watching an AI work

Here is a use that matters a great deal right now. When you have an AI assistant making changes to your project, Git becomes your window and your safety rail at once.

Before the AI starts, you have a clean snapshot. After it works, you run git status and git log, and you can see exactly what it touched — every file, every line, changed or added. Nothing is hidden. And if you don’t like what it did, you return to your snapshot from before, and it’s as though it never happened.

So Git gives you three things over an AI working on your code: observability (you see precisely what changed), control (you decide what to keep), and reversibility (you can always undo). That’s what lets you hand real work to a fast assistant without losing your grip on it.

So, in one breath

Git is your fearless undo: it remembers every version of your work in snapshots you name, lets you return to any of them, lives privately on your own computer, and — whether you’re experimenting boldly or watching an AI change your files — gives you the calm certainty that you can always see what happened and always go back.