Modern Git Academy
Modern Git Academy teaches the tools and workflows behind modern software development — from your first Git commit through GitHub, CI/CD, security, DevOps and AI-assisted engineering.
Most Git material teaches a command list. That gets you through the first month and then stops working, because a list of commands gives you nothing to reason with when something unexpected happens. This Academy teaches the model underneath: what Git is actually doing with your files, commits, branches, references and objects, so its behaviour becomes predictable rather than memorised.
Learning areas
Section titled “Learning areas”The Academy is organised into pillars covering the modern engineering toolchain. Git Fundamentals, Modern Git Workflows, GitHub Engineering, GitHub Actions & CI/CD, Git Security & DevSecOps, GitHub Copilot & AI Engineering, Git for DevOps & Infrastructure and Git at Scale & Enterprise Engineering are published now, alongside a collection of hands-on labs. The remaining areas are in development, and nothing is published here until it is complete — you will not find placeholder pages or stub tutorials on this site.
Continue learning
Pick up where you left off- Git Fundamentals
- Modern Git Workflows
- GitHub Engineering
- GitHub Actions & CI/CD
- Git Security & DevSecOps
- GitHub Copilot & AI Engineering
- Git for DevOps & Infrastructure
- Git at Scale & Enterprise Engineering
- Hands-On Git & GitHub Labs
See everything in My Academy →
Progress is stored in this browser only and never sent anywhere.
Not sure where to start?
Section titled “Not sure where to start?”Three hundred lessons is a lot of surface area, and the hard part is rarely finding a page — it is knowing which fifteen to read, in what order, for what you are actually trying to do.
Answer one question about where you are, and get a sequenced route through the curriculum.
Choose your learning pathGit Fundamentals
From your first commit to advanced Git internals.
12 lessons available
Modern Git Workflows
Branches, merging, rebasing, worktrees, large repositories, automation, configuration and secure developer workflows.
33 lessons available
GitHub Engineering
Repositories, pull requests, reviews, governance, GitHub CLI, APIs, webhooks and developer automation.
42 lessons available
GitHub Actions & CI/CD
Build, test, secure, package and deploy software with GitHub’s automation platform.
47 lessons available
Git Security & DevSecOps
Protect repositories, credentials, code, dependencies, CI/CD systems, artifacts and software supply chains.
35 lessons available
GitHub Copilot & AI Engineering
AI-assisted Git workflows, GitHub Copilot across editors and the terminal, AI code review, agent configuration, MCP and software-development agents.
41 lessons available
DevOps & Infrastructure
Use Git to manage infrastructure code, containers, Kubernetes, GitOps, Ansible, environments and platform engineering workflows.
45 lessons available
Git at Scale & Enterprise Engineering
Operate Git and GitHub across enormous repositories and large organisations: monorepos, LFS, enterprise governance and rulesets, identity and provisioning, audit and compliance, and repository fleet engineering.
45 lessons available
Hands-On Labs
Guided scenarios you break and repair in a disposable repository: recover a deleted branch, resolve a conflict, repair a rebase, debug and secure a workflow, ship an infrastructure change.
20 labs available
Git Fundamentals
Section titled “Git Fundamentals”The first pillar is a twelve-lesson curriculum designed to be worked through in order. It takes a reader with no version control experience to the point of reading a commit object out of Git’s object database by hand.
The sequence is deliberate. Lessons 1–3 build the mental model before you type a command. Lessons 4–6 set up your environment on whichever platform you use. Lesson 7 is a full hands-on tutorial. Lessons 8–12 examine each part of Git’s architecture in depth, and become the reference material you return to.
- Lesson 1: 01. What Is Git?Git is a distributed version control system that records project history as snapshots. Learn what it does, why it exists, and how developers use it.
- Lesson 2: 02. Git vs GitHubGit is version control software you run locally. GitHub is a hosting platform built around it. Here is exactly where one ends and the other begins.
- Lesson 3: 03. How Git Actually WorksA complete walkthrough of Git's data model: the working tree, the index, the object database, refs, and what git add and git commit really do.
- Lesson 4: 04. Installing Git on UbuntuInstall Git on Ubuntu with apt, verify the version, and configure identity, default branch, editor and credentials across all three config scopes.
- Lesson 5: 05. Installing Git on WindowsInstall Git on Windows with winget or the official installer, then configure line endings, the credential manager, default branch and your editor.
- Lesson 6: 06. Installing Git on macOSInstall Git on macOS using Xcode Command Line Tools or Homebrew, understand which binary you are running, and configure identity and credentials.
- Lesson 7: 07. Your First Git RepositoryCreate a repository, stage a file, make commits, read the log and diff your changes — a full hands-on walkthrough that explains every command.
- Lesson 8: 08. Understanding the Working TreeWhat the Git working tree is, how it differs from the index and the repository, and what tracked, untracked, modified, deleted and ignored actually mean in git status.
- Lesson 9: 09. Understanding the Git IndexThe index is a real file that holds the next commit's exact content. Learn what it stores, why Git has one, and how partial staging works.
- Lesson 10: 10. Understanding HEADHEAD is a symbolic reference to your current branch. Learn how it moves, what detached HEAD means, and how HEAD~ and HEAD^ navigate history.
- Lesson 11: 11. Git Objects ExplainedGit stores everything as four object types in a content-addressable database. Explore blobs, trees, commits and tags with real plumbing commands.
- Lesson 12: 12. Git Repository StructureA guided tour of a real .git directory — HEAD, config, index, objects, refs, logs, hooks and packed-refs — and which of them are conditional.
Continue your Git learning
Section titled “Continue your Git learning”The Academy is designed as a progression. Each pillar assumes the one before it and goes further.
- Git FundamentalsWhat Git is and how it actually works — 12 lessons.
- Modern Git WorkflowsHow engineering teams actually use Git — 33 lessons across four clusters.
- GitHub EngineeringRepositories, pull requests, reviews, governance, the CLI and the APIs — 42 lessons.
- GitHub Actions & CI/CDAutomating builds, tests, releases and deployments — 47 lessons.
- Git Security & DevSecOpsSecuring repositories, credentials, code, dependencies and the software supply chain — 35 lessons.
- GitHub Copilot & AI EngineeringCopilot across editors and the terminal, AI code review, and delegating work to agents — 41 lessons.
- Git for DevOps & InfrastructureTerraform and OpenTofu repositories, container identity, Kubernetes GitOps, Ansible and platform engineering — 45 lessons.
- Git at Scale & Enterprise EngineeringEnormous repositories, enterprise governance and rulesets, identity and provisioning, audit and compliance, and repository fleet engineering — 45 lessons.
Pillar 1 teaches the model. Pillar 2 teaches the decisions built on top of it. Pillar 3 covers engineering as a team on GitHub, and Pillar 4 automates that lifecycle. Pillar 5 asks the question the first four leave open: how do you know the software you deploy is the software you reviewed? Pillar 6 adds AI to all of it — Copilot, AI review and software-development agents — on the principle that AI should accelerate engineering without removing engineering discipline. Pillar 7 turns the whole apparatus on infrastructure itself, where Git is not merely where the code lives but where infrastructure change becomes reviewable, auditable, automatable and — through GitOps — continuously reconcilable. Pillar 8 changes the scale rather than the subject: what happens to all of it when repositories reach tens of gigabytes, engineering organisations reach thousands of people, and every decision about governance, identity and automation has to hold across an entire estate rather than a single repository.
How these lessons are built
Section titled “How these lessons are built”The Academy is a technical education site, not a link farm. Every article is written to be genuinely useful to a working engineer, and follows a consistent structure so it works as reference material as well as a tutorial.
Clear technical explanations Concepts explained from first principles, with the reasoning behind Git’s design rather than a list of rules to memorise.
Real command-line examples Every command is shown with what it does, why it is being run, and the output to expect — captured from a real Git installation, not reproduced from memory.
Original diagrams Lightweight, accessible diagrams where a picture genuinely helps — always alongside a prose explanation, never instead of one.
Common mistakes The errors that actually recur, with the reasoning that makes each one avoidable rather than just a warning to memorise.
Troubleshooting Real error messages, what they mean, and what to do — so you can diagnose a problem instead of searching for its exact wording.
Reference tables Comparisons, flag summaries and status-code tables you can scan quickly when you need the answer rather than the explanation.
Hands-on exercises Try It Yourself sections that ask you to predict Git’s behaviour before observing it — the fastest way to find out where your model is wrong.
Next-step learning paths Every lesson ends by pointing at what to read next and why, so the curriculum reads as a sequence rather than a pile of articles.
Written for engineers
Section titled “Written for engineers”Accuracy over publication speed. Commands are verified against a real Git installation before they are published. Platform-specific instructions follow primary documentation from the Git project and the relevant vendor, not tutorials of unknown vintage.
Version-sensitive content is marked. Installation guides, package manager commands and vendor interfaces all age. Lessons covering them record what they were verified against, and evergreen concepts are kept separate from version-specific instructions.
Destructive commands are treated seriously. Operations that can lose work — git reset --hard,
git restore, force-pushing — are explained with their consequences, given safer alternatives where
they exist, and never presented casually to beginners. Exercises use disposable repositories.
No invented authority. There are no fabricated author biographies, no invented statistics, no testimonials and no course-completion theatre. Articles are published under the Academy’s own name.
When you want the files, not the lesson
Section titled “When you want the files, not the lesson”The curriculum is free and stays free. Two optional one-time purchases contain the finished artefacts the lessons describe, for engineers who would rather adapt a reviewed file than assemble one: the GitHub Actions Production Workflow Vault ($9.99) — twenty pinned, least-privilege workflows for CI, containers, security, releases and cloud deployment — and the Professional Toolkit ($19.99) — decision guides, CODEOWNERS and pull request templates, GitHub API scripts and repository checklists. Compare them against the free plan; one file from the Toolkit is published free so you can judge the standard before paying anything.
Modern Git Weekly
Get one practical Git technique, one useful GitHub workflow, and one security lesson in your inbox each week.
Not open yet
Rather than collect addresses with nowhere to send them, signup is closed until delivery is set up. Everything on the site is free without it — theRSS feed carries every new lesson in the meantime, and thesample issue shows exactly what the email is.