Shug Meets Git (And Gets Confused Immediately)

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:

1. google "how to push code to github"

2. copy paste commands

3. hope it works

4. it works

5. 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:

• tracks changes in your code

• stores complete history

• works locally on your computer

• doesn't need internet

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 = your brain keeping memories

• github = google photos backup

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:

• what changed (diff)

• who changed it (shug)

• when it changed (timestamp)

• why it changed (commit message)

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:

• where is git storing all this data?

• what is HEAD?

• how do commits connect?

• what are branches actually?

time to look inside.

🎬 continue to episode 3