Git tutorial

Learn how to track code changes and work safely with other developers.

Start the course

Course contents

Orientation

  1. Git Basics — What Git does, the chain of snapshots behind it, your first repository and first commit, how commits are named, and how to tell Git who you are.

Daily Work

  1. Ignoring Files — What .gitignore does, how to write the patterns, why ignoring a file you already committed changes nothing, and how to stop tracking one without deleting it.
  2. Daily Workflow — The loop you live in: reading git status, what git add really records, the ways to stage, recording deletions, committing well, and amending the last commit.
  3. Reviewing Changes — Reading what you changed before you commit it, comparing branches and commits, walking the history with log, and opening a single commit with show.
  4. Undoing Changes — The two kinds of undo before a commit: unstaging safely, discarding permanently, restoring a file from an older commit, undoing a staged deletion, and cleaning untracked files.

Branching and Merging

  1. Branches — What a branch really is, creating and switching and deleting them, what switching does to your files, detached HEAD, and the feature-branch habit teams rely on.
  2. Moving Changes — Parking uncommitted work with stash, managing the stash list, copying a single commit with cherry-pick, and resolving a conflict in the middle of one.
  3. Merging Changes — Fast-forward versus a real merge commit, how three-way merging decides, resolving a conflict from start to finish, aborting safely, and shaping history with --no-ff and --squash.

Working with Others

  1. Hosting Platforms — Where Git stops and GitHub or GitLab begins: the vocabulary side by side, the merge buttons translated, the settings worth turning on, and what does and does not move between hosts.
  2. Remote Repos — The three kinds of branch, what ahead and behind and diverged mean, cloning, managing remotes, why fetch is safe when pull is not, rejected pushes, and upstream tracking.
  3. Collaboration Workflows — The six-step loop a team runs, keeping a branch current, the three ways a branch lands, why a squashed branch looks unmerged, force-pushing safely, and protected branches.
  4. Rewriting History — What rebase does to your commits and why their hashes change, when it is safe, resolving conflicts mid-replay, interactive rebase, and moving a branch with --onto.

When Things Go Wrong

  1. Fixing Mistakes — Choosing between amend, reset and revert, the three reset modes and what each one keeps, undoing a shared commit safely, and when rewriting history is allowed.
  2. Recovering Work — What the reflog records, why lost commits are usually still there, recovering from a bad reset or a deleted branch or an unwanted rebase, and the limits of reflog recovery.
  3. History Investigation — Reading the shape of a repository's history, narrowing to one file, finding when a line of code appeared with the pickaxe, using blame, and bisecting to the exact bad commit.

Deeper

  1. Git Foundations — Why commits are snapshots rather than diffs, the four object types and how they chain together, content-addressed hashing, the three trees, HEAD and branches, and why ignore rules cannot reach a tracked file.
  2. Releases & Tags — Lightweight versus annotated tags, generating version strings with git describe, why tags are not pushed with your commits, and what signing adds to a release.
  3. Branch Strategies — Choosing between GitHub Flow, Git Flow and trunk-based development, running the full Git Flow lifecycle, generating versions from history, and branch naming conventions.
  4. Git Customization — The three configuration levels and which wins, the settings worth turning on once, aliases, keeping work and personal identities apart, and why hooks are a convenience rather than a control.
  5. Advanced Repositories — Several checkouts sharing one object store, what worktrees share and keep separate, and submodules: what the gitlink records, how updates work, and when a package is the better answer.
  6. AI Workflows — Using Git when an agent writes the code: checkpoints before a run, one branch per task, a worktree per simultaneous agent, commit hygiene that allows partial rejection, and reviewing work you did not write.
  7. Large Repositories — Telling the three kinds of too-big apart, shallow clones for CI, sparse checkout for monorepos, partial clones that fetch contents on demand, Git LFS for binaries, and repository maintenance.
  8. Git Internals — Inside the .git directory, how an object's name is computed from its type and contents, what trees store beyond names, why renames are inferred, and the plumbing commands that never lie.

Reference

  1. Error Guide — The Git messages you will actually meet, decoded: what fatal, error, warning and hint each mean, the families they fall into, and the four commands that answer almost any of them.
  2. Git Cheat Sheet — Every command on this course in one place, grouped by the job you are doing: starting out, the daily loop, branching, remotes, undoing, moving work, investigating, plumbing, settings, and the destructive ones.