• Copy some commands

• Paste them in terminal

• Hope nothing breaks

That works… until it doesn’t.

This blog is about understanding Git just enough so you can use it confidently without memorizing random commands.

What Is Git (In Simple Terms)

Git is a version control system.

That means:

• It keeps track of changes in your project

• It remembers past versions

• It lets you go back when something breaks

Think of Git as a time machine for your code.

You write code → save checkpoints → experiment freely → undo if needed.

Why Git Is Used (The Real Reasons)

Git exists because real projects have problems like:

• “This worked yesterday, now it’s broken”

• “Which change caused this bug?”

• “I want to try something risky without fear”

• “Multiple people working on the same code”

Git solves this by:

• Keeping history

• Tracking changes

• Making experiments safe

• Enabling collaboration

Without Git, development is fragile.
With Git, mistakes become cheap.

Core Git Concepts (No Jargon Overload)

Before commands, you need the language.

Repository (Repo)

A repository is just:

A project that Git is tracking

When you initialize Git in a folder, that folder becomes a repository.

Commit

A commit is:

A saved snapshot of your project at a point in time

Each commit has:

• What the project looked like

• Who saved it

• When it was saved

• A message explaining why

Think:- Commit = checkpoint

Branch

A branch is:

An independent line of development

You can:

• Try new features

• Experiment safely

• Not affect the main code

Beginner takeaway:

Branches let you explore without breaking things

HEAD

HEAD simply means:

Where you are right now in Git history

It points to:

• The current commit

• On the current branch

That’s it. No mystery.

Essential Git Commands (The Ones You Actually Use)

You don’t need 50 commands.
You need a small set used repeatedly.

git init — Start Git Tracking

git init

What it means:

“Start tracking this folder with Git”

This creates a hidden .git folder where Git stores history.

git status — Know What’s Going On

git status

This is your most important command.

It tells you:

• What files changed

• What’s staged

• What’s not committed yet

Run this often. Seriously.

git add — Select What to Save

git add file.txt

or

git add .

This means:

“I want Git to include these changes in the next commit”

It does not save history yet.
It prepares changes.

git commit — Save a Snapshot

git commit -m "Add login feature"

This creates a permanent checkpoint.

Rule of thumb:

• One logical change = one commit

• Message explains why, not just what

git log — View History

git log

This shows:

• Past commits

• Who made them

• When

• Messages

This is how you travel back in time.

A Basic Git Workflow (From Scratch)

Let’s walk through a realistic beginner workflow.

Step 1: Create a project

mkdir my-project
cd my-project

Step 2: Initialize Git

git init

Now Git is watching this folder.

Step 3: Create a file

touch index.html

Edit it. Add some content.

Step 4: Check status

git status

Git tells you:

“I see new changes, but I’m not tracking them yet”

Step 5: Add changes

git add .

Now Git knows what you want to save.

Step 6: Commit

git commit -m "Initial project setup"

Boom. First checkpoint created.

Step 7: Repeat

Change → status → add → commit
That’s 80% of Git usage.

The Mental Model to Remember

Don’t think:

“Which Git command should I run?”

Think:

“What do I want Git to remember right now?”

Git is about:

• History

• States

• Safety

Not commands.

Common Beginner Mistakes (Quick Warnings)

• Skipping git status

• Making huge commits with many unrelated changes

• Writing useless commit messages like “update”

• Being afraid to commit often

Commit early. Commit often.
Git is built for that.

Final Thought

Git is not hard.
It’s just unfamiliar at first.

Once the basics click:

• You stop fearing mistakes

• You experiment more

• You become a better developer

Learn Git early.
Your future self will thank you.