There are only two kinds of fear in the developer world:
- A merge conflict in a month-old feature branch,
- A ringing phone.
And if you gave me the choice between resolving thirty “both modified in HEAD” conflicts and calling someone to “just check on that status,” I’m picking the merge every single time.
Because at least Git errors make sense eventually. Humans? Not so much.
Why Are Phone Calls the Final Boss of Adulthood?
There’s something about phone calls that make even the most competent developer regress into a panicked intern.
You can deploy an entire production app at midnight, juggle microservices like a magician, but the moment you have to call your service provider? Suddenly you’re pacing the room rehearsing your lines like you’re auditioning for Les Misérables.
It’s the anticipation that kills you.
The ringing tone stretches out like an eternity; long enough to rethink all your life choices, from that untested commit to the moment you chose computer science over communication studies.
When the person finally answers, your brain throws a fatal exception.
“Hi, yes, I’m calling because… uh… my… code… I mean… account.”
Merging Chaos: The Lesser Evil
Now, let’s talk about that month-old feature branch.
It’s dusty. Ancient. The kind of branch that’s seen things.
Merging it into main feels like performing digital archaeology; each conflict a fossil of who you used to be before you “temporarily” switched tasks and never came back.
You scroll through the conflicts, whispering prayers, your screen a battlefield of red and green. Every diff is a mystery:
- Who wrote this? (You did.)
- Why would they do that? (Also you.)
- Does this even compile anymore? (Probably not.)
And yet, it’s meditative. You can control it. You can fix it. Unlike a phone call, Git won’t ask “How’s your day going?” or leave awkward silences that make you question your social skills.
In a world full of unpredictable interactions, merge conflicts are comforting. They’re chaotic, yes, but they’re honest chaos.
A Developer’s Paradox
Developers are paradoxical creatures. We’ll build full-stack apps that automate conversations, but dread having actual ones.
We’ll Slack, Teams, email, comment on Jira tickets, and even send memes with context clues instead of picking up the phone. Because text gives you time. Time to think, time to backspace, time to Google how to sound human in professional tone.
A phone call, though? It’s real-time reality. There’s no Ctrl + Z in a conversation.
It’s raw, immediate, and messy… which is why we avoid it with the same intensity we avoid refactoring legacy code we didn’t write (but secretly suspect we did).
Maybe It’s Not About Fear
Okay, maybe it’s not just about fear. Maybe it’s about comfort zones.
When you live in a world of logic and syntax, you crave predictability.
The compiler tells you what’s wrong. The linter scolds you in detail. The phone? The phone leaves you hanging in uncertainty; no stack trace, no clue where you went wrong.
So maybe this isn’t a war between phone calls and Git merges.
Maybe it’s a quiet love letter to the structured chaos of coding.
Because yes, merging old branches is terrifying… but at least it’s our kind of terrifying.
At the end of the day, both merge conflicts and phone calls teach us the same thing: communication is messy, whether it’s between branches or people.
But if you ever catch me choosing one over the other… just know that I’m knee-deep in merge hell before I’m dialing that number.
If this post made you feel seen (or if you, too, rehearse phone calls like Shakespearean soliloquies), stick around. Subscribe for more stories from the code trenches, told by your favorite dev girl who still prefers conflict resolution via Git, not conversation.
Days in the Life of Mo 
Leave a Reply