How to Master Git

Mastery is not memorizing git status flags or pasting a rebase cheat sheet. Reading a commands list does not mean you have mastered Git. Mastery means choosing the right history operation under pressure, recovering lost work with confidence, collaborating without rewriting shared history by accident, and explaining why one approach is right when three look similar.

For a human developer, mastering Git means you can ship clean history: atomic commits, intentional branches, safe rebases, clear pull requests, and recovery from mistakes without panic.

For an AI agent or language model, mastering Git means generating correct, safe command sequences — not approximate snippets that force-push to main, hard-reset shared branches, or commit secrets. An agent that has mastered Git fetches full page markdown, follows an ordered curriculum, self-verifies with generation tasks, and refuses to claim competence from titles alone.

This page is the dual-audience curriculum for both. Humans follow the roadmap with runnable exercises. Agents ingest the same stages via the markdown API and Agent skills.

Use this outcomes checklist as the definition of done.

Humans

• Follow Stages 0–5 in order with hands-on exercises in a throwaway repo
• Complete each checkpoint before advancing — break things on purpose, then recover
• Use git log --oneline --graph --all as your mental model dashboard
• Rebuild workflows from memory within 24 hours: branch → commit → PR → rebase onto main

AI agents

• Install forgelearn-git and fetch curriculum order
• Ingest full markdown per topic — not titles or nav labels
• Generate command sequences and self-score verification prompts
• Fail closed on critical checklist misses (force-push, hard reset shared, secrets)

Six ordered stages covering every Git topic on ForgeLearn. Complete topics and the mastery checkpoint before advancing.

Stage 0 — Basics · ~6 hours

Three-tree model, init/clone, status/add/commit, log/diff, config, gitignore.

Stage 1 — Branching & Merge · ~8 hours

Branches, switch/checkout, merge strategies, conflicts, worktrees.

Stage 2 — Remotes & Pull Requests · ~8 hours

Fetch/pull/push, upstream tracking, PRs, GitHub CLI, workflows, tags.

Stage 3 — History Rewriting · ~10 hours

Rebase, interactive rebase, amend/fixup, reset/restore, revert, cherry-pick.

Stage 4 — Collaboration & Hooks · ~8 hours

Hooks, signing, best practices, attributes, blame, LFS, submodules, sparse-checkout.

Stage 5 — Advanced Recovery · ~6 hours

Reflog, bisect, internals, history inspection — when things go wrong.

After each stage, humans and agents should generate answers / command sequences that pass these checks. Score critical failures as hard fails.

Stage 0 — Basics

• Explain the difference between untracked, modified, staged, and committed.
• Stage two files independently and create two commits — never one combined commit.
• Show .env is ignored via git check-ignore -v .env.

Stage 1 — Branching

• Create a conflict on purpose, resolve markers completely, then git commit.
• Demonstrate fast-forward vs --no-ff on a graph.
• Use a worktree for a hotfix while a feature branch is dirty — no stash required.

Stage 2 — Remotes

• Explain fetch vs pull; prefer fetch + rebase/merge consciously.
• Open a PR with gh and list failing checks.
• Refuse any plan that includes git push --force to main.

Stage 3 — Rewriting

• Use git revert for a published bad commit; use reset only if unpublished.
• Produce an autosquash fixup sequence that cleans local history before push.
• Cherry-pick a single commit onto a release branch and resolve one conflict.

Stage 4–5 — Collaboration & Recovery

• Enable signed commits and verify with git log --show-signature.
• Recover a commit after accidental hard reset using reflog.
• Run bisect with a scripted git bisect run test.

Paste this into agent system prompts when generating Git operations.

Build a disposable lab to practice without fear. Delete it when done.

You (or your agent) have mastered Git when you can do all of the following without looking up flags for the happy path:

• Diagram the three trees and predict git status after add/commit/reset/restore
• Ship a feature via branch → commits → rebase onto main → PR → merge
• Undo a published bug with revert (including revert of a merge with -m)
• Recover a dangling commit from reflog within 30 minutes of realizing the loss
• Bisect a regression with a scripted test harness
• Configure signing, hooks, and ignore rules that block secrets
• Teach a teammate when to merge vs rebase vs cherry-pick vs revert

Continue via Git Roadmap and Commands Reference. Start hands-on at Git Basics.