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 and Modern Git Workflows are published now. 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.
Git 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.
38 lessons available
GitHub Engineering
Repositories, pull requests, the GitHub CLI, REST and GraphQL APIs, collaboration and governance.
In development
GitHub Actions
CI/CD pipelines, automation, runners, reusable workflows and deployments.
In development
Git Security
Repository security, secret management, commit signing, supply-chain security and DevSecOps.
In development
DevOps + Git
Docker, Kubernetes, Terraform, Ansible, GitOps and platform engineering workflows.
In development
AI + Git
GitHub Copilot, AI code review, coding agents and AI-assisted repository engineering.
In development
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 TreeThe working tree is the checkout you edit. Learn tracked, untracked, modified, deleted and ignored files, and how git status reads them.
- 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, APIs and governance — in development.
Pillar 1 teaches the model. Pillar 2 teaches the decisions built on top of it: when a branch should exist, how changes should reach the main branch, whether history should be merged or rebased, and how to work efficiently in repositories of any size.
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.