How I Became The “Git Guy” at Work

So here’s a weird flex, but ok here goes: I’m the person my team calls when Git goes sideways.

Not because I’m some Git wizard who memorized the entire man pages. Not because I have years of experience with complex merge strategies. Honestly? It’s because I use GitKraken and GitLens and everyone else is still raw-dogging the command line or Visual Studio.

The Phone Call That Started It All

Picture this: It’s 11AM on a Tuesday. I’m deep in code, in the zone. Teams Call — of course.

“Hey, uh… can you come look at something? We tried to merge for the release and now there are like… 47 conflicting files. We’ve been staring at this for an hour.”

I walk over. There’s three developers huddled around a monitor, with Release Management looking at a wall of conflict markers in VS Code. They’ve been manually resolving conflicts one by one, losing track of which files they’ve touched, not really sure if they’re making things better or worse. Only able to get part of the way then, it’s just too many files.

I pull up GitKraken. Maybe 10 minutes later, the merge is done. Pushing to RC.

Thanked me for my help. But guess what? Any time any one has a conflict, call Wyatt.

How This Keeps Happening

Here’s the thing about my workplace: we have a massive repo with a monolithic API. It’s a centralized API where all things flow through, so any time anyone has to add/update a feature, it happens here. When multiple teams are working on features in overlapping services and someone decides to merge a major branch, it can create absolute chaos.

The command line approach looks like this:

git merge feature-branch
# CONFLICT (content): Merge conflict in src/...
# CONFLICT (content): Merge conflict in src/...
# CONFLICT (content): Merge conflict in src/...
# ... (repeat 45 more times)

Then you’re supposed to open each file, find the conflict markers, figure out what to keep, save it, git add it, and somehow keep track of what you've done and what you haven't.

With 60+ files? You’re going to miss something. You’re going to lose track. You’re going to make a mistake.

The GitKraken Difference

When I open that same merge conflict in GitKraken, I get:

1. A list of all conflicted files — Right there in the panel. I can see exactly what needs attention, all in 1 view.
2. The merge tool — Click any file, and I get a three-way view: their changes on the left, my changes on the right, the result in the middle. Checkboxes for “take theirs,” “take mine,” or manually edit.
3. Visual indicators — Files I’ve resolved are checked off. Files still needing work are highlighted. I can’t forget one.
4. Context — Hover over any change and see the full commit that introduced it. Who wrote it, when, why.

For that 47-file nightmare? I knocked it out in maybe 10 minutes. And I was confident in the result because I could see everything.

The Time We Had To Merge Four Branches At Once

This was the one that really cemented my reputation.

We had four feature teams that had been working in parallel for months. All four branches needed to merge into dev before a major release. The branches had diverged significantly. We’re talking hundreds of commits, dozens of files changed in overlapping ways.

The lead developer tried to do it manually. After 2 hours of trying to fix it, he gave up and called me.

Here’s what GitKraken let me do:

First, I could actually see what we were dealing with. The commit graph showed me all four branches, where they diverged, what commits were unique to each. I could plan the merge strategy before touching anything.

Second, I merged them one at a time, using the visual merge tool for each conflict. Branch A into dev. Resolve conflicts. Test. Branch B into dev. Resolve conflicts. Test. And so on.

Third, when conflicts happened (and oh boy, did they happen), I could see the full context. Not just the conflict markers, but why the conflict existed. Which team made which change, when, and what they were trying to accomplish.

The whole thing took maybe two hours. The lead developer watched over my shoulder for part of it and just kept saying “wait, you can do that?”

Why Everyone Else Struggles

I’ve watched really smart developers absolutely struggle with Git. Not because they’re bad at their jobs, but because Git’s command-line interface is hostile to human brains. It’s not about intelligence, its about using the right tool.

When you’re in the terminal, you’re working with:

• Text you have to parse mentally
• State you have to track in your head
• Relationships between commits that you have to visualize
• A fear of doing something wrong because you can’t see what will happen

It’s like trying to navigate a city with only text directions and no map.

GitKraken is the map.

The Stuff I Use Daily

The Commit Graph — This is the big one. I can see our entire branch structure at a glance. When someone asks “wait, did the authentication changes make it into the release branch?” I don’t have to run a bunch of commands. I just look.

The Merge Tool — Three-way merge view with checkboxes. Makes conflicts actually manageable. I can see what changed on both sides, make intelligent decisions, and track what I’ve resolved.

Interactive Rebase — Drag and drop commits to reorder them. Squash commits together. Split commits apart. Stuff that’s terrifying in the terminal is just… visual.

Blame View — Right-click, see who wrote every line. Hover for the full commit message. Instant context for “why is this code like this?”

Cherry-Pick — Right-click a commit, pick the branch, done. No memorizing SHAs.

File History — See every change ever made to a file in a visual timeline. Incredibly useful for tracking down when bugs were introduced.

The Moment I Realized I Was “The Git Guy”

It was when I’m not the “Merge Marshal” but I always get roped into fixing merge conflicts.

It’s the difference of starting regression today or tomorrow, and as we’re all aware “time is money”. Using the right tool allows you to deliver more, faster.

It’s like the difference between doing carpentry with hand tools versus power tools. Sure, you can build a house with a hand saw and a hammer. But why would you when you have a circular saw and a nail gun?

The Thing Nobody Talks About

Here’s what using GitKraken actually taught me: understanding Git concepts.

Because I can see what a rebase does, I understand it better — before it ever happens. I can watch commits move in the graph. I understand why cherry-picking can cause issues because I can see the duplicate commits it creates. I understand merge strategies because I can visualize the result.

The visual representation made me better at the underlying tool.

It’s like learning to drive with a good instructor versus just being handed keys and told “figure it out.”

The Honest Truth

I still use the command line and VS code’s build in Git pane for quick stuff. git add ., git commit -m "...", git push - the terminal is fine for the basics.

But anything complex? Merges, rebases, understanding branch structure, resolving conflicts, code archaeology? GitKraken or GitLens every time.

Could you do everything GitKraken does in the terminal? Technically, yes. But you’d need to memorize a bunch of commands, visualize the graph in your head, and be really, really careful not to screw something up.

Or you could just… see it.

Would I Recommend It?

Look, if you’re happy with your current Git workflow and you’re not dealing with complex branches or merge conflicts, you probably don’t need it.

But if you:

• Work on a team with multiple active branches
• Deal with merge conflicts regularly
• Want to understand what’s actually happening in your repository
• Are tired of being scared of Git
• Want to be the person people call when Git breaks (weird flex but okay)

Then yeah, try it. There’s a free version that works great. Pro version has team features and is totally worth it if you’re doing serious work.

For me? It turned me from “person who uses Git nervously” to “the Git guy.” And honestly, that’s been pretty cool.

The Real Win

The best part isn’t that I can fix merge conflicts faster. It’s that I’m not scared anymore.

I used to approach complex Git operations with anxiety. “Am I about to mess this up? Should I make a backup branch? What if I lose work?”

Now? I can see exactly what will happen before I do it. I can undo things easily if I need to. I can experiment without fear.

Git went from “necessary evil” to “tool I actually enjoy using.”

And that’s worth way more than just being fast at merges.

nyway, that’s my story. If you want to check it out, it’s at gitkraken.com. There’s a free version for open-source projects and a discounted Pro license if you want to test the team features.

Are you “the Git person” at your job? What made you that person? Let me know in the comments — I’m curious if there are other accidental Git masters out ther