Go beyond the basics — understand git reset, merge, rebase, and remote well enough to make decisions confidently.
What you'll learn
✓ Understand git reset in all three modes — know exactly what --soft, --mixed, and --hard each do to your three trees, and when to use each.
✓ Recover commits with reflog — use Git's reference journal to find and restore commits you thought were gone after a reset or bad operation.
✓ Know which merge strategy Git uses and why — understand fast-forward vs three-way merge, and resolve conflicts when they come up.
✓ Use interactive rebase — reword, squash, fixup, and drop commits, handle conflicts mid-rebase, and undo a rebase cleanly.
✓ Understand what push, fetch, and pull are actually doing — including remote-tracking branches and why Git rejects non-fast-forward pushes.
✓ Know why force-push is destructive and how to protect against it — including --force-with-lease and how to recover from a force-push disaster.
✓ See how your Git decisions affect your teammates — and understand the real cost of choices that seem harmless when you only think about yourself.
Requirements
● Basic hands-on Git experience — you should be comfortable with git add, git commit, and switching branches. This course picks up where day-to-day Git use leaves off. (Note:If you are completely new to Git with no prior experience, start with Course 1. This course assumes you have used Git before, even if you're not confident in it.)
● No Git internals knowledge required. If you've taken Course 1 of this series, the foundation will make things click faster — but it is not a requirement.
Description
You use Git every day. But do you feel confident in it — or are you still making decisions by guessing, hoping nothing breaks, and copying commands from Stack Overflow without fully understanding them?
That gap between using Git and understanding Git is exactly what this course closes.
This is not a beginner course that walks you through 'git add' and 'git commit'. You already know those. This course is for developers who have some Git knowledge & experience but want to stop feeling uncertain — developers who want to understand what 'git reset' is actually doing, why a rebase can go wrong and how to fix it, and how their Git decisions ripple out to every other developer on their team.
What you will understand by the end
You will start with Git's reference management — how branches and tags work at the file level, how 'git reset' moves a branch pointer, and what it means to reset with '--soft', '--mixed', or '--hard'. And when something goes wrong, the reflog means almost nothing is ever truly lost — you will know exactly how to use it.
From there, you will learn to merge with confidence: fast-forward merges, three-way merges, and the full conflict resolution workflow. You will also learn 'git stash' — and why applying a stash can trigger the same kind of conflict as a merge.
Then comes rebase — covered in full depth. You will understand what rebasing actually does to commits, how to use interactive rebase to reword, squash, fixup, and drop commits, and how to choose between rebase and merge based on your team's strategy.
The section on remotes brings it all together. You will see how remote-tracking branches work, why Git enforces fast-forward-only pushes, what happens when multiple developers push simultaneously, and how force-push can corrupt shared history — and also how to recover from it.
The course closes with something most Git courses never address: developer velocity! Your Git decisions don't just affect you. They multiply across your whole team. This section quantifies that impact and reframes what Git mastery actually means in the age of AI.
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.
AI can tell you to rebase — and it might even be right. But without a deep understanding, you have no way to know. You can't evaluate the answer, catch a bad call, or push back with a better one. You have to trust it and hope.
This course gives you the understanding that lets you work with AI tools effectively, not just alongside them blindly.
What makes this course different?
Commands can be looked up. AI will write them for you. What can't be automated is understanding — the intuition for how Git models your project's history, the judgment to make the right collaboration decision, the ability to reason about what's happening and why. That's the human side of version control. That's what this course is built around. You will forget the commands, but you will never forget the concepts!
25 + 7 Optional Prerequisites lectures. The full practical toolkit. The judgment to use it well.
Who this course is for
■ Developers who use Git but don't fully trust it — you know the commands, but you're not always sure what they do. You want to stop guessing.
■ Anyone who has struggled with rebase, reset, or merge conflicts — and wants to understand what's actually happening, not just follow steps until it works.
■ Developers who work on teams and want to make Git decisions that don't create problems for the people around them.
■ Anyone preparing for Course 3 in this series — GitHub: pull requests, branch protection, Actions, and organization-level collaboration.