Git for Beginners: Basics and Essential Commands
If you’re new to Git, chances are you’ve already seen a list of commands like:
git init
git add
git commit
And thought:
“Okay… but what do these actually do?”
In this blog, we’ll slow things down and build Git knowledge from the ground up.
No rushing. No jargon overload. Just clear concepts and a simple workflow.
What Is Git?
Git is a version control system.
In simple words:
Git helps you keep track of changes in your code over time.
It allows you to:
Save versions of your project
Go back to older versions
Work safely with other developers
Understand who changed what and why
Git does this locally on your machine, even without the internet.
That’s why Git is called a distributed version control system — every developer has a full copy of the project and its history.
Why Git Is Used
Before Git, developers:
Shared code using zip files
Overwrote each other’s work
Lost track of changes
Had no clear history
Git solves all of that.
With Git, you get:
A complete history of your project
Safe collaboration
Easy bug tracking
Confidence to experiment without fear
Once you use Git properly, working without it feels risky.
Git Basics: Core Terminologies You Must Know
Before touching commands, let’s understand a few important words.
These concepts matter more than memorizing syntax.
Repository (Repo)
A repository is where Git tracks your project.
It includes:
Your project files
A hidden
.gitfolder that stores history
Think of a repository as:
“A project folder with memory”
Commit
A commit is a snapshot of your project at a specific point in time.
Each commit:
Saves the current state of your files
Has a message explaining the change
Becomes part of the project history
Think of commits like save points in a game.
Branch
A branch is a separate line of development.
It allows you to:
Work on new features
Fix bugs
Experiment safely
All without breaking the main code.
You’ll learn more about branches later — for now, just know they exist to keep work isolated.
HEAD
HEAD is simply a pointer to where you currently are in the project history.
In simple terms:
HEAD = “your current commit”
Essential Git Commands (Beginner-Friendly)
Now let’s look at the most important Git commands — the ones you’ll use every day.
git init — Start Git Tracking
This command creates a new Git repository.
git init
What it does:
Creates the
.gitfolderTells Git: “Start tracking this project”
You usually run this once per project.
git status — Check What’s Going On
git status
This is your most-used command.
It tells you:
Which files are changed
Which files are staged
What Git is waiting for
Whenever you’re confused, run git status.
git add — Prepare Changes
git add file.txt
or
git add .
This command:
Takes changes
Puts them into the staging area
Staging means:
“These changes are ready to be committed”
Nothing is saved to history yet.
git commit — Save a Snapshot
git commit -m "Add login feature"
This command:
Creates a commit
Saves a snapshot of staged changes
Adds a message for clarity
Good commit messages explain why, not just what.
git log — View History
git log
This shows:
All commits
Commit messages
Authors and timestamps
This is how Git lets you travel back in time.
A Simple Git Workflow (From Scratch)
Let’s put everything together.
Step 1: Create a Project
mkdir my-project
cd my-project
git init
Step 2: Create or Edit Files
index.html
style.css
Step 3: Check Status
git status
Step 4: Stage Changes
git add .
Step 5: Commit Changes
git commit -m "Initial project setup"
Repeat this cycle:
Change → Add → Commit
That’s the core Git workflow.
What Git Is Really Doing
Behind the scenes:
Git stores snapshots
Links commits together
Tracks history safely
Never loses data easily
Commands are just ways to talk to this system.
Once you understand the workflow, Git starts feeling natural.
Common Beginner Mistakes (And How to Avoid Them)
Forgetting to commit regularly
Writing unclear commit messages
Being scared to experiment
Memorizing commands without understanding
Focus on concepts first. Commands will follow.
What’s Coming Next in the Series
In the next part, we’ll cover:
Git vs GitHub (very important)
Local vs remote repositories
How push and pull actually work
Final Thoughts
Git is not about commands.
It’s about:
History
Safety
Confidence
Collaboration
Once the basics are clear, Git becomes one of the most powerful tools in your developer toolkit.
And this is just the beginning 🚀
