Learn Git & GitHub — from first commit to advanced workflows

A guided path from your very first commit to the advanced Git and GitHub workflows professional teams use. Start with what version control actually is, build a rock-solid mental model of how Git stores your work, then learn branching, collaboration on GitHub, and the power tools — rebase, bisect, Actions — that separate confident users from the rest.

Start lesson 1 →Jump to glossary

Git has a reputation for being confusing — detached HEADs, rebases, force pushes, that one command everyone copy-pastes from Stack Overflow. It doesn’t have to be. Almost all of that confusion comes from skipping the mental model and memorising commands instead. This path fixes that: we start with what version control actually does, build a clear picture of how Git stores your work, and only then layer on branching, collaboration, and the power tools.

Who this is for. Total newcomers welcome — no prior Git, command-line mastery, or programming background assumed. Already comfortable with add, commit, and push? Use the module list to jump straight to branching, rebasing, GitHub Actions, or the best-practices module.

How the path works. Six modules take you from your first commit to advanced team workflows. The early modules are pure Git — knowledge that applies whether you host on GitHub, GitLab, or your own server. The later modules move onto GitHub itself: pull requests, issues, Actions, and the guardrails that keep a shared main branch healthy. Mark lessons complete as you go — your progress is saved in your browser. New here? Start with lesson 1: Why version control?

Module 1 — Version Control Foundations

Why version control exists, how Git thinks, and the core loop — edit, stage, commit — you'll use every day.

  1. Why version control? What a version control system is, the problems it solves, and why Git won — the one idea everything else builds on. beginner 8 min
  2. Installing & configuring Git Getting Git on Linux, macOS, and Windows, then setting your name, email, editor, and a few sane defaults. beginner 7 min
  3. How Git thinks: snapshots, not diffs Commits, trees, blobs, and the SHA — the object model that makes Git fast, safe, and a little magic. beginner 10 min
  4. Your first repository init vs. clone, the working tree, and what actually lives inside the .git directory. beginner 8 min
  5. The staging area & commits add, the index, and commit — how to compose a clean, deliberate snapshot instead of dumping everything. beginner 9 min

Module 2 — Everyday Git

The handful of commands you'll run dozens of times a day — reading state, history, and safely undoing mistakes.

  1. Reading status & diffs status, diff, and diff --staged — knowing exactly what has changed and what's about to be committed. beginner 8 min
  2. Viewing history with log & show log, show, and blame — navigating the past, formatting output, and finding who changed what and why. beginner 8 min
  3. .gitignore & tracking the right files Keeping secrets, build artifacts, and noise out of your repo — patterns, precedence, and global ignores. beginner 7 min
  4. Undoing changes: restore, reset & revert The three ways to go back — and how to tell which one you need without losing work or rewriting shared history. intermediate 10 min

Module 3 — Branching & Merging

Git's superpower — cheap branches — and how to bring lines of work back together cleanly.

  1. Branches explained What a branch really is (a movable pointer), creating and switching them, and HEAD demystified. intermediate 9 min
  2. Merging & fast-forwards Fast-forward vs. three-way merges, merge commits, and when each one happens. intermediate 8 min
  3. Resolving merge conflicts Why conflicts happen, how to read the markers, and a calm, repeatable process for resolving them. intermediate 9 min
  4. Rebasing & a linear history Replaying commits onto a new base for a clean history — and the golden rule of never rebasing shared work. advanced 10 min
  5. Stashing work in progress Parking uncommitted changes to switch context fast, then bringing them back without losing anything. intermediate 6 min

Module 4 — Remotes & GitHub

Taking Git online — pushing to GitHub, authenticating securely, and the fork-and-pull-request workflow.

  1. What is GitHub? GitHub vs. Git, what a remote-hosting platform adds, and the alternatives (GitLab, Bitbucket, Codeberg). beginner 8 min
  2. Remotes: clone, fetch, pull & push origin, tracking branches, and the difference between fetch, pull, and push — the sync model in full. intermediate 9 min
  3. Authentication: SSH keys & tokens Why HTTPS passwords are gone — setting up SSH keys or a personal access token so pushes just work. intermediate 9 min
  4. Forking & the fork workflow Forks vs. clones, keeping a fork in sync with upstream, and how open-source contribution actually flows. intermediate 8 min
  5. Pull requests & code review Opening a PR, writing a good description, requesting review, and turning feedback into merged code. intermediate 10 min

Module 5 — Collaboration & GitHub Features

The platform features that turn a code host into a place teams plan, automate, ship, and protect their work.

  1. Issues, labels & Projects Tracking work with issues, organizing it with labels and milestones, and planning on Projects boards. beginner 9 min
  2. CI/CD with GitHub Actions Workflows, jobs, and steps — automating tests, builds, and deploys that run on every push and PR. advanced 11 min
  3. Tags, releases & semantic versioning Marking versions with tags, publishing Releases with notes and binaries, and what SemVer numbers mean. intermediate 9 min
  4. Pages, Gists, Discussions & wikis The extras worth knowing — free static hosting, shareable snippets, community Q&A, and project wikis. beginner 8 min
  5. Branch protection, reviews & CODEOWNERS Required reviews, status checks, and CODEOWNERS — the guardrails that keep a shared main branch healthy. advanced 8 min

Module 6 — Advanced Git & Best Practices

The power tools and habits that mark a confident operator — history surgery, debugging, and clean workflows.

  1. Rewriting history with interactive rebase Squash, reword, reorder, and drop commits to craft a tidy history before you share it. advanced 10 min
  2. Cherry-pick, bisect & the reflog Grab a single commit, binary-search for the commit that broke things, and recover work you thought was lost. advanced 10 min
  3. Submodules, hooks & worktrees Nesting repos, automating checks with hooks, and checking out multiple branches at once — the lesser-known tools. advanced 9 min
  4. Branching strategies: trunk, GitHub Flow & Git Flow How teams organize branches — and how to pick the model that fits your team's size and release cadence. intermediate 9 min
  5. Commit hygiene & best practices Atomic commits, good messages, small PRs, and the habits that make a repo a pleasure to work in. intermediate 8 min
  1. Glossary of Git & GitHub terms Plain-language definitions for every Git and GitHub term in the learning path, cross-linked to the lessons.