Build a solid mental model of Git — understand commits, branches, and the three-tree model from the inside out.
What you'll learn
✓ Understand Git's object model — how blobs, trees, and commits are stored as content-addressed objects connected by hashes.
✓ Understand references in Git — how HEAD, branches, and tags are just text files with a hash, and what detached HEAD state actually means.
✓ Master Git's three-tree model — work tree, index tree, and head tree — and understand exactly what git add, diff, restore, and commit do to each.
✓ See how Git detects every kind of change — modified, new, deleted, and renamed files — using content hashes, with no guessing.
✓ Understand what happens internally when you commit or switch commits — no magic, just objects, references, and three trees updating in sequence.
✓ Read Git documentation confidently and use AI tools effectively — knowing what questions to ask and how to evaluate the answers you get.
Requirements
● Basic computer literacy is enough — you should be comfortable using a computer and asking AI tools for help when needed. No prior Git knowledge required.
● A willingness to think conceptually. This course rewards curiosity about WHY things work, not just HOW to use them.
Description
Knowing which command to type gets you through a tutorial.
Understanding what Git is actually doing gets you through your career.
There's a difference between memorizing commands and seeing your project the way Git does — as a series of saved states connected by hashes. When that mental model clicks, you stop reacting to Git and start reasoning with it. Commands that used to feel unpredictable become obvious. Situations that used to feel dangerous become navigable.
You might forget the exact syntax after a few months. You will never forget how Git thinks.
This is the first course in a three-part series. It covers one thing entirely: understanding how Git works from the inside out.
What you will understand by the end
You will start with Git's object model — the blobs, trees, and commit objects that Git creates every time you stage and commit. You will see how these objects are named after their own content using SHA hashes, how a commit is nothing more than a snapshot of a folder at a point in time, and how Git avoids storing duplicate content entirely.
From there, you will learn how references work — HEAD, branches, and tags — and how they are just text files containing a hash. When you understand that, the detached HEAD state stops being frightening.
Then comes the three-tree model: the work tree (your project folder), the index tree (the staging area), and the HEAD tree (your last commit). Git's entire logic — `git add`, `git diff`, `git restore`, `git commit` — is just moving content between these three trees. Once you see that, every command has an obvious purpose.
The AI Era Angle
AI tools can write Git commands for you, and often write them correctly. The limiting factor isn't the AI — it's your ability to evaluate what it gives you. You don't know what you don't know. Without deep understanding, you can't catch a wrong answer, spot a flawed suggestion, or steer toward the right solution. You become the liability in that interaction, not the asset.
This course gives you the understanding that lets you work with AI tools effectively, not just alongside them blindly.
What makes this course different?
Most Git courses teach you commands. This one teaches you the system underneath the commands. Not as a curiosity — because it changes how you think about everything that comes after: history management, collaboration, and the judgment calls that separate a developer who uses Git from one who understands it.
25 lectures. One coherent mental model. The foundation for everything Git.
Who this course is for
■ Complete beginners to Git who want to build the right mental model from day one — not memorize commands they don't understand.
■ Developers who already use Git but feel uncertain — you've been using it for months or years but still feel like you're guessing. This course gives you the model you never got.
■ CS students and self-taught developers who want to understand version control at a deeper level than tutorials usually go.
■ Anyone preparing for the next course in this series — Git in Practice — where this foundation gets applied to history management and team collaboration.