Git Finally Makes Sense

· 4 min read
gitversion-controltools

For weeks, Git was this scary thing I avoided. I knew I needed to learn it, but the commands seemed cryptic and I was afraid of breaking something.

Now it finally makes sense, and I wish I had learned it sooner.

Why I Avoided Git

The commands looked scary: git rebase, git cherry-pick, git reflog what do these even mean?

I was afraid of losing my code: What if I mess up and delete everything?

I didn’t see the point: I was the only one working on my projects. Why did I need version control?

The tutorials were confusing: They explained what Git does but not why I should care.

The Breakthrough

What finally made Git click was understanding the problem it solves.

Without Git:

  • I had folders named project, project-final, project-final-v2, project-final-actually-final
  • I was afraid to make big changes because I might break something
  • I couldn’t experiment without copying the entire project
  • I had no history of what changed and why

With Git:

  • One folder, all history preserved
  • I can try new things and easily go back if they don’t work
  • I can see exactly what changed and when
  • I can work on multiple features without them interfering

Once I understood this, I was motivated to learn Git properly.

The Basic Workflow

Here’s what I use Git for every day:

# Start tracking a project
git init

# See what changed
git status

# Stage changes
git add .

# Save changes with a message
git commit -m "Add user authentication"

# See history
git log

This basic workflow covers 80% of what I do.

Understanding Branches

Branches were confusing at first, but now they’re my favorite Git feature.

A branch is like a parallel version of your project where you can experiment without affecting the main code.

# Create and switch to a new branch
git checkout -b new-feature

# Work on the feature, make commits

# Switch back to main branch
git checkout main

# Merge the feature
git merge new-feature

This lets me work on multiple things without them interfering with each other.

GitHub Changed Everything

Learning Git locally was one thing, but connecting it to GitHub opened up new possibilities:

Backup: My code is safe even if my computer dies Portfolio: I can show my projects to potential employers Collaboration: I can work with others (haven’t done this much yet) Learning: I can read other people’s code

Basic GitHub workflow:

# Connect local repo to GitHub
git remote add origin https://github.com/username/repo.git

# Push code to GitHub
git push origin main

# Get latest changes
git pull origin main

Mistakes I Made

Committing too much at once: My commits were huge and hard to understand. Now I make smaller, focused commits.

Bad commit messages: “Fixed stuff” doesn’t help future me. Now I write descriptive messages.

Not committing often enough: I would work for hours without committing. Now I commit after each small feature or fix.

Working directly on main: I should use branches for new features, even when working alone.

Being afraid of the command line: I tried GUI tools first, but learning the commands helped me understand Git better.

Commands I Use Daily

git status          # What changed?
git add .           # Stage all changes
git commit -m ""    # Save changes
git push            # Upload to GitHub
git pull            # Download from GitHub
git log             # See history
git diff            # See exact changes

Commands I’m Learning

git branch          # Manage branches
git merge           # Combine branches
git stash           # Temporarily save changes
git reset           # Undo things (carefully!)

What I’m Still Learning

  • Resolving merge conflicts
  • Rebasing (still not sure when to use this)
  • Git workflows for teams
  • Advanced commands like cherry-pick and reflog

Resources That Helped

  • Git documentation: Actually pretty good once you understand the basics
  • Oh Shit, Git!: Website with solutions to common Git problems
  • GitHub’s Git guides: Simple and practical
  • Practice: Making mistakes and fixing them taught me the most

Advice for Beginners

Start simple: Learn init, add, commit, push, pull. That’s enough to get started.

Commit often: Small, frequent commits are better than large, rare ones.

Write good commit messages: Future you will thank you.

Don’t be afraid: You can’t really break Git. Even if you mess up, there’s usually a way to fix it.

Use it for everything: Even small projects. The practice helps.

Learn the command line: GUI tools are nice, but understanding the commands helps you understand Git.

Why You Should Learn Git

It’s required: Almost every development job expects you to know Git.

It makes you confident: You can experiment without fear because you can always go back.

It’s a time machine: See what your code looked like at any point in history.

It enables collaboration: Working with others requires version control.

It’s your portfolio: GitHub is where you show your work to the world.

What’s Next

Now that I’m comfortable with Git basics, I want to:

  • Learn about Git workflows (Git Flow, GitHub Flow)
  • Practice resolving merge conflicts
  • Contribute to open source projects
  • Learn more advanced commands

Git went from scary to essential. I use it every day now, and I can’t imagine coding without it.

If you’re avoiding Git, stop. Learn the basics. It’s easier than you think, and it will make you a better developer.

All articles