🌱 How I First Broke Everything (and What It Taught Me)

When I first started using Git about a decade ago, I thought I was being smart by making changes directly on the main branch.

Spoiler alert: I wasn’t. One day, I pushed some half-baked code to production, and everything fell apart. It was a painful lesson—but it led me to discover Git branches, and everything changed from there.

If you’re tired of feeling anxious every time you commit code, this post is for you. Let’s dive into how Git branches can help you become a more confident SDET.

🌳 What is a Git Branch?

Imagine you’re writing a novel 📖. You’re happy with Chapter 1, but now you want to experiment with Chapter 2 without messing up the original. Instead of editing the main file, you make a copy, work on the copy, and merge it back if it works. That’s exactly what a Git branch does in code.

A branch is simply a lightweight movable pointer to a specific commit. You can think of the main branch as your primary storyline, and other branches as side quests or experiments you can safely run.

💡 Why Branches Matter

• 🧪 Safe experimentation: Try out new features without affecting the main code.
• 👥 Collaboration: Multiple developers can work in parallel without stepping on each other’s toes.
• 💾 History: You can always trace back and understand what changes happened, where, and why.

🔨 Essential Git Branch Commands (Without the Confusion)

Here’s how you start working with branches like a pro.

✅ git branch – View or Create Branches

• git branch → Lists all branches
• git branch new-feature → Creates a new branch called new-feature

✨ Pro Tip: Add a naming convention like feature/signup-form or bugfix/login-error for better clarity.

🔁 git checkout – Switch Between Branches

• git checkout new-feature → Switches to the new-feature branch

🎯 Pro Tip: Starting from Git 2.23, you can also use:

• git switch new-feature

It’s simpler and more intuitive.

🧬 git merge – Bring Changes Together

• git merge new-feature → Merges changes from new-feature into your current branch (usually main)

⚠️ Warning: Always pull the latest changes before merging to avoid conflicts.

🤝 Real-Life Example: Adding a Contact Form

Let’s say you’re building a website and want to add a contact form.

1. Create a branch:
   git branch contact-form
2. Switch to it:
   git checkout contact-form
3. Build your feature.
4. When done, switch back to main:
   git checkout main
5. Merge it in:
   git merge contact-form

Voila! Your feature is live and your main branch remained untouched until it was ready. 🧼

🎯 Expert Tips & Best Practices

✅ Keep branches small and focused
One branch = one task. This keeps code reviews quick and reduces merge conflicts.

✅ Use pull requests (PRs)
Even if you work solo, PRs help document your thought process and keep code review in check.

✅ Delete old branches
Once merged, remove them with git branch -d branch-name to keep things tidy 🧹

✅ Name branches clearly
Use formats like feature/, bugfix/, or hotfix/ to indicate purpose.

⚠️ Common Mistakes to Avoid

❌ Working directly on main
It’s risky. Always branch off.

❌ Not pulling the latest changes before merging
This often leads to conflicts. Always sync first: git pull

❌ Merging without testing
Test your feature branch before merging into main.

Your Next Git Moves

Using Git branches was a turning point in my SDET journey. It turned chaos into calm and gave me the confidence to experiment, collaborate, and grow.

👣 Next Steps:

• Create your first branch today!
• Start using git switch for a smoother experience.
• Write cleaner branch names that your future self will thank you for.

📚 Bonus: Git Branch Cheatsheet

• git branch → List branches
• git branch new-branch → Create branch
• git checkout branch-name → Switch to branch
• git merge branch-name → Merge into current branch
• git branch -d branch-name → Delete branch

💬 Got Questions or Branch Nightmares?

Drop them in the comments or DM me—I’ve broken plenty of things and lived to tell the tale. 😉