From git push to actually appreciating Git

I've been using Git for years, but for a long time I was mostly living in add → commit → push land. I learned the deeper parts whenever I actually needed them.

At one point, I had watched 400+ Git videos, but honestly, watching and understanding are two different things.

Most of what I learned properly came when I had to solve a real problem.

This is just me saying thanks. Because Git is one of those things I used for years without actually understanding what I was holding.

When Git was just an upload button

When I was new to development, I started using Git after HTML, CSS, JavaScript and React.

And at that point Git was basically this:

git add .
git commit -m "done"
git push

That's it. That's the whole workflow. I mostly used it because I wanted to put my code on GitHub. Like the green boxes were the goal, not the history.

I tried learning Git properly more than once — different people, those 15-minute videos. Honestly most of it didn't stick. I was still working mostly solo so I never felt why I needed all those other commands. You don't really understand rebase when nobody else is touching the same files as you.

So I stayed in add-commit-push land for a long time. And it was fine. Until it wasn't.

Then collaboration happened (kind of)

I started working more with other people. Still a lot of solo work tbh, but now there were PRs and branches that weren't just main and "please don't break this".

Over the years, I kept running into more Git features that made me appreciate it. Not from a course. Just from getting stuck and googling the exact error.

Little by little, commands like cherry-pick, reset --hard, rebase, reflog, stash, merge started making sense. Not all at once. Like one command every few weeks whenever I actually needed it.

Then jobs happened. Real repos. Real people. Real "why is this commit on staging but not on this other branch" situations.

The cherry-pick that changed how I look at Git

A few years ago, I had one of those moments with Git that completely changed how I looked at it.

I needed to cherry-pick a commit from a different repository.

I already knew how to use git cherry-pick, but this time I started thinking about what Git actually had to do internally for this to work.

You can fetch from a completely different repo and apply the change from one of their commits onto your current branch. Not a full merge. Not copy-paste the files.

git cherry-pick does not take the same commit and insert it into your history. It takes the change that commit introduced, applies it where you are, and creates a new commit. Same idea. Different SHA.

Something like:

git fetch https://github.com/someone/other-repo.git main
git cherry-pick <commit-sha>

Or if you're going to do it more than once:

git remote add other https://github.com/someone/other-repo.git
git fetch other
git cherry-pick <commit-sha>

What made it even better was I figured out what I needed logically first. Git commits point to a tree representing the project state and reference their parent commits. So if I can get that commit into my object database, I should be able to apply the change it introduced. I didn't just copy a StackOverflow command and pray.

That moment really changed how I looked at Git.

I stopped seeing it as a tool for pushing code to GitHub. I started seeing it as this slightly insane, very well thought out system for managing how software actually evolves.

And Over the Years, Git Kept Surprising Me

Not a cheatsheet. Just the ones that made the respect go up over time.

git reflog

The first time I recovered something I thought I had deleted, I started appreciating how much Git keeps track of behind the scenes.

You know that feeling after git reset --hard where your stomach drops and you think the work is gone.

It isn't immediately gone. Git is quietly keeping a local log of where HEAD has been. Those entries don't live forever — they're local, and Git eventually prunes them — but in the moment, it's there.

git reflog
git checkout <that-old-sha>

Like they built an undo for people who panic. Which is all of us.

git stash

I needed to switch branches in the middle of messy work more times than I can count. git stash became the obvious answer once I understood what it was actually doing — park my changes, switch, come back.

git stash push -m "wip: login form half done"
git checkout main
 
# do the urgent thing
 
git checkout -
git stash pop

Simple. It saved me so many "let me just copy this to a notepad real quick" moments.

Git also has worktree, which lets you have multiple branches checked out at the same time. I've used it, but for my usual workflow I still reach for stash more often.

Quick context switch → stash
Parallel work         → worktree

git rebase

This one took me the longest. People make it sound scary and ngl it is a bit scary the first time.

I had a branch that needed to sit on top of newer work. Once I understood rebase as replaying commits on a newer base, it finally clicked.

git fetch origin
git rebase origin/main

Interactive rebase (git rebase -i) is the same idea, except you get to squash, reword, drop — like editing a draft before you hit send.

git reset --hard

Dangerous, yes. Also the cleanest way to say "this experiment was a bad idea, take me back".

git reset --hard origin/main

This doesn't just "undo". It moves the current branch pointer and resets your working tree and index to match that commit. If you have uncommitted changes, they can be destroyed.

I treat it like a sharp knife. Very useful. Don't swing it around when you have work you actually want.

(And if you do... reflog. See above.)

git log --oneline --graph

I used to think git log was just a wall of text.

git log --oneline --graph --decorate --all

Once I started looking at the graph, a lot of "wait why is this branch like this" questions answered themselves.

git bisect

When something broke and you don't know which commit did it, instead of checking out random old commits like a maniac, Git can binary-search the history for you.

git bisect start
git bisect bad
git bisect good <last-known-good-sha>

Used this once on a real bug and felt like I had unlocked a cheat code.

What I actually respect now

The more I use Git, the more I realise how much thought is sitting underneath something that looks so simple from the outside.

When you're a beginner it's three commands. When you go a bit deeper it's this whole model:

working tree
    ↓
index
    ↓
commit ──→ tree
    │
    └────→ parent commit(s)
 
references ──→ commits
branches / tags ──→ references
objects ──→ commits, trees, blobs, tags
remotes ──→ remote-tracking references

I don't need to explain all of that here. Just knowing there is a coherent model — not a bag of random commands — is what changed things for me.

And most of the core thing is sitting right there on your laptop. You don't need GitHub for Git itself to work.

Git ≠ GitHub.

GitHub is a hosting / collaboration platform. Git is distributed version control. I wish someone had told me that on day one, when I thought git push was Git.

That's not an accident. People built this. People have been maintaining it for years. Linus Torvalds started it. Junio Hamano has maintained it for a very long time. And a lot of people kept showing up to make it better, fix the weird edge cases, write docs, review patches, keep it boring and reliable so the rest of us can ship.

I've been using Git for years, and the more I understood what was underneath the commands, the more I appreciated it.

I used it without understanding it. Then I understood a little. Then I cherry-picked a change across repos by thinking through how Git could do it, and the respect just... went up.

So this is the post.

Thank you to Linus Torvalds, Junio Hamano, the Git contributors, and the maintainers who still keep this thing going.

You gave developers a tool that a lot of us first use as a GitHub upload button. And then one day we actually see it. And it's kind of beautiful.

From my first:

git push

to sitting there going wait, rebase, reset, reflog, cherry-pick... this is actually insane.

What a journey. ❤️

Thank you for Git.