←
·4 min

I want to learn git

Learning Git (aka: faking it for way too long)

I first touched Git back in 2020 during my apprenticeship.

Some senior dev casually dropped:

This is important. You need versioning.

And that was it.

No explanation. No context. Just one of those cryptic developer commandments handed down from the mountain.

Cool. Thanks. Super helpful.

At that point I barely knew how to code, let alone what versioning even meant. Repository? Commit? Push? It all sounded like corporate buzzwords people use to feel productive.

My first project was a tiny REST API in C# that stored everything in JSON files like some kind of budget database crime scene. And Git was just… there. Existing. Judging me.

All I knew was:

  • there’s something called a repo
  • you commit stuff
  • you push stuff
  • and if you mess up, something probably explodes

Nobody explained why.

And when you don’t even know what question to ask, Googling is useless.

Searching “git how work pls help” doesn’t exactly unlock enlightenment.

Meanwhile, I actually learned to code

Over the next few years, I drifted into web development.

HTML. CSS. JavaScript. The usual pipeline of suffering.

Then frameworks showed up.

First React. Then Next.js.

Suddenly things clicked.

I could build real stuff. Not toy scripts. Actual applications.

I got better at:

  • structuring projects
  • working with databases
  • deployments
  • APIs
  • basically everything needed to ship something usable

So my dev skills improved fast.

But Git?

Git stayed this mysterious black box I poked occasionally with a stick.

My dirty little secret

If I’m being honest… I’m not even really using Git.

I’m using VS Code’s Git integration like it’s Fisher-Price: My First Version Control System™.

Big friendly buttons. Green checkmarks. Cute little messages like “Sync Changes”.

Click Commit. Click Push. Click Pull.

Done.

It feels safe. Suspiciously safe.

Because under the hood Git is doing a million things… and I understand maybe two of them.

The UI basically translates everything into:

Don’t worry buddy, I’ll handle it.

Which sounds nice — until you realize you’ve learned absolutely nothing.

It’s like driving a car for five years and never learning where the brakes are.

My current “workflow” (if you can call it that)

Honestly, it’s basically this:

  • stage everything
  • write some vague commit message like "stuff"
  • hit sync
  • pray

That’s not version control.

That’s superstition.

The moment something weird happens — merge conflicts, detached HEADs, rebasing, anything slightly advanced — the friendly buttons disappear and suddenly it’s just me and a blinking cursor.

And I realize:

I didn’t learn Git.

I learned buttons.

And buttons don’t exist outside the editor.

The terminal does.

Cold. Unforgiving. No safety net. Just:

git status

…and your mistakes staring back at you.

Where I want to be

At some point it gets embarrassing.

I can design apps. Ship projects. Deploy to production.

But Git still feels like dark magic.

That’s backwards.

Git isn’t supposed to be a boss fight. It’s supposed to be the safety net.

So I’m done hiding behind the UI.

I want to type commands and actually know what they do:

git commit
git branch
git rebase
git cherry-pick

Not because a button did it for me — but because I understand what’s happening.

Less:

please work please work please work

More:

yeah, this is exactly what I intended

No more training wheels.

Time to face the terminal like an adult and stop treating version control like some ancient ritual.

Conclusion: buttons aren’t the problem — ignorance is

Here’s the thing.

Buttons aren’t bad.

VS Code gives an insanely good developer experience. The UI is clean, the errors are readable, everything feels smooth. It’s honestly great engineering.

But buttons without understanding?

That’s dangerous.

Because a button is just a pretty disguise for a command that can absolutely ruin your day.

One wrong click and:

  • history is rewritten
  • commits disappear
  • branches get nuked
  • and you’re googling “how to undo everything I just did” at 2am

If I don’t know what the button actually does, I’m not being productive — I’m gambling.

Sooner or later I will do more harm than good.

So this isn’t about ditching the UI because “real devs use the terminal”.

It’s about not being clueless.

I want to understand the machine first.

Then I can use the buttons.

Not the other way around.

This post (and probably a few more) is me finally learning Git properly — from the ground up — instead of pretending I know what I’m doing.

Let’s see how painful that journey gets. 🚀

6 views