Is Git Confusing? A Git Crash Course to Get You Started!

Git might seem confusing at first — branches, merges, rebases, conflicts. But underneath it all, Git is just a time machine for your code. This guide is interactive: step through the animations, play through branching strategies, and use the scenario picker when you're stuck.

What is Git?

Git tracks every snapshot (commit) of your code. Don't like the latest version? Go back to any earlier one.

Git's 5 Staging Areas

1. Working Directory — where you edit files
2. Staging — preview of your next snapshot
3. Commit Tree — saved history
4. Stash — temporary storage
5. Remote — GitHub / GitLab in the cloud

Interactive: Add → Commit → Push

Interactive: Stash & Pop

Daily Git Commands

These are the commands you'll actually use every day.

git status                    # what changed?
git diff                      # show line-by-line changes
git add .                     # stage everything
git commit -m "message"       # save snapshot
git push origin main          # upload to remote
git pull origin main          # download + merge latest
git checkout -b feature/name  # create + switch branch
git switch main               # switch branch (modern)
git stash / git stash pop     # park & restore work
git log --oneline --graph     # visual history

Branching — Your Superpower

Branches let you work on features without touching main.

Interactive: Create a Feature Branch

git branch -a                 # list all branches
git checkout -b feature/login # create + switch
git push -u origin feature/login

Branching Strategies — Interactive Walkthrough

Different teams organize branches differently. Step through each strategy below — watch how work flows from branch to production.

Quick comparison

GitHub Flow — one main branch, feature branches, PRs. Best for most web teams shipping daily.

Git Flow — main + develop + feature/release/hotfix branches. Best when releases are scheduled (mobile, desktop).

Trunk-Based — everyone integrates to main frequently, branches live hours. Best for large teams with strong CI and feature flags.

Which should you pick?

• Solo / startup / web app → GitHub Flow
• Scheduled releases (v1.0, v2.0) → Git Flow
• Large team, continuous deploy + feature flags → Trunk-based

Merging — Combining Branches

Interactive: Merge

git checkout main
git pull origin main
git merge feature/login
git push origin main

Interactive: Merge Conflicts

<<<<<<< HEAD
Hello Friend
=======
Hello World
>>>>>>> feature-branch

Fix: edit file → remove markers → git add → git commit.

Rebasing — Sync With Main

Replay your commits on top of latest main. Use this on your own feature branch before opening a PR.

Interactive: Rebase

git checkout feature/my-feature
git fetch origin
git rebase origin/main
# conflicts? fix → git add . → git rebase --continue
git push --force-with-lease

Merge vs Rebase — daily rule

Squash merge (common on GitHub)

Combines all PR commits into one clean commit on main. Great for messy WIP history.

git rebase -i HEAD~3   # locally: squash before pushing

Daily Scenario Picker

Pick your situation — get the commands you need right now.

Your Typical Day With Git

# Morning — sync up
git checkout main && git pull origin main
git checkout feature/my-feature
git merge main                    # bring in overnight changes

# During the day — commit often
git add .
git commit -m "Add checkout step"
git push

# Before PR — clean up (optional)
git rebase -i HEAD~3              # squash WIP commits
git push --force-with-lease

# After PR merged — clean up locally
git checkout main && git pull
git branch -d feature/my-feature

Complete Feature Workflow

git clone https://github.com/username/project.git
cd project
git checkout -b add-user-profile

# work, commit, push
git add . && git commit -m "Add user profile page"
git push -u origin add-user-profile

# open PR on GitHub → review → merge
git checkout main && git pull
git branch -d add-user-profile

Undo Cheat Sheet (daily)

Tips That Save You Daily

1. Commit often — small commits are easier to review and revert
2. Branch for everything — never commit directly to main
3. Pull main before you start — sync at the start of the day
4. Read git status — it tells you what to do next
5. Use PRs — even solo, PRs give you a review checkpoint
6. Delete merged branches — keep your repo tidy

Key Takeaways

• add → commit → push is your daily loop
• Branch for every change — merge via PR
• Pick a strategy — GitHub Flow for most teams
• Rebase your own branch to stay current with main
• Merge conflicts are normal — fix, add, commit
• Use the interactive tools — strategies animation + scenario picker

Happy coding!