the tutorial trap
shug opens youtube.
searches: "git tutorial for beginners"
watches 45 minute video.
learns commands:
git init
git add .
git commit -m "initial commit"
git push origin main
shug copies commands.
everything works.
but shug has no idea what just happened.
repeat after me syndrome
for next 3 months, shug's workflow:
google "how to push code to github"
copy paste commands
hope it works
it works
still no understanding
shug becomes copy paste developer.
the breaking point
one day shug's teammate asks:
"can you merge my branch?"
shug: "what is branch?"
teammate: "you don't know branches?"
shug: "i know git push"
teammate: 😐
time to actually learn.
what git actually is
shug sits down.
reads carefully.
git = version control system
okay but what does that mean in real terms?
git is tool that:
git vs github (shug was confused)
shug thought git = github.
wrong.
git → software on your computer (the brain 🧠)
github → website that stores git projects (the cloud ☁️)
analogy:
git works without github.
github is useless without git.
mind blown 🤯
the .git folder revelation
shug types first real command:
git init
nothing visible happens.
but shug checks folder.
hidden folder appears: .git
this is where everything lives.
all history.
all commits.
all branches.
all memory.
delete this folder → git forgets everything
shug stares at .git folder with respect.
how git remembers (the actual flow)
shug draws diagram in notebook:
working directory
↓
git add
↓
staging area
↓
git commit
↓
.git folder (permanent storage)
step 1: working directory
shug edits index.html:
<h1>hello world</h1>
git notices change.
but does nothing yet.
shug checks:
git status
output:
modified: index.html
git is watching.
step 2: staging area (the waiting room)
git add index.html
change moves to staging area.
staging = "i want to remember this change"
git status now shows:
Changes to be committed:
modified: index.html
still not permanent.
shug can unstage if needed.
step 3: commit (permanent memory)
git commit -m "added hello world heading"
now git saves it forever.
commit stores:
this snapshot is now permanent.
even if shug deletes file later, git remembers.
the commands shug actually uses
seeing what changed
git status
shows current state.
seeing history
git log
shows all commits.
better version:
git log --oneline
cleaner output.
seeing specific changes
git diff
shows line-by-line changes before staging.
shug's first real workflow
day 1: shug creates project
mkdir my-project
cd my-project
git init
git is now watching this folder.
day 2: shug adds files
touch index.html
git add index.html
git commit -m "added index file"
first commit created ✅
day 3: shug makes changes
edits index.html
git add index.html
git commit -m "updated heading"
second commit created ✅
day 4: shug checks history
git log --oneline
output:
a1b2c3d updated heading
e4f5g6h added index file
shug can see everything that happened
no more mystery.
no more "when did i change this?"
the realization moment
shug accidentally deletes entire file.
panics.
then remembers: git has history.
git checkout HEAD index.html
file comes back.
shug's hands stop shaking.
this is why git exists.
but questions remain
shug understands commands now.
but still confused about:
time to look inside.
🎬 continue to episode 3
