Every Software Developer Has Blamed…

I got back from FrontKon in Prague today (well, technically yesterday, since I'm publishing this tomorrow), and I'm DEAD! 😂

The conference itself was fantastic, of course. Both my panel discussion and my talk went really well, and the Czech developer community is starting to feel like family. Greetings from your favorite senior software vývojářka! 😀

I'll write my usual, more technical article next week. I want to approach the topic from a slightly different angle, so I need a bit more time for research. Meanwhile, flights from Gdańsk to Prague depart at the absolutely murderous hour of 6 AM, which means that at 3:30 AM today, I was still in Prague!

And since some of you have recently been asking for another installment of my "You're a Real Software Developer Only If…" series, here you go!

Who or what has every software developer blamed at least once? Here's my list!

1. Another Developer

Obviously, if the code is terrible, it's never our fault. Someone else must have messed it up. A colleague from our team, someone from another team, or the developer who worked on the project before us.

Quite often, though, that "other developer" turns out to be ourselves from six months ago. 😅

2. The Company

Because the processes are terrible, the standards are nonexistent, and management clearly has no idea what they're doing. The poor developer has been thrown into this corporate machine and is now forced to fight an endless battle against the system.

Things get a little awkward when you're self-employed and your company consists of… well, you. xD

3. Legacy Code

The application could be just six months old, and somehow there will already be legacy code somewhere. And naturally, that legacy code is responsible for every bug, every delay, and every missed delivery deadline!

4. The Framework

It's buggy! It's unpredictable! It's missing half the features we need!

If I wrote my own framework, now THAT would be something! And why haven't I done it yet? Well, I never promised anyone I would! 😅

5. The Client

Let's be real: our jobs would be so much easier and more enjoyable if it weren't for that annoying client who keeps asking for things and complaining about everything. 🤣

6. The Backend

This is personally my first suspect whenever something goes wrong. If something doesn't work, it MUST be the fault of whoever wrote the backend.

I mean, come on. Are you seriously suggesting that something could possibly be wrong with MY code???

7. The Frontend

And this is exactly what backend developers think about the frontend whenever someone reports a bug.

Yes, yes, I know. In the age of AI, many of us have become full-stack developers, whether we wanted to or not. But deep down, our hearts will always belong a little more to one of those "ends." ☺️

8. The Requirements

Obviously. They're either too vague, poorly written, or based on some completely ridiculous idea invented by the stakeholders.

And even if the requirements are absolutely perfect, there's probably something missing from the documentation anyway. 😉

9. The Cache

Come on, admit it. If you've never told someone to "clear your cache," can you even call yourself a software developer???

10. CORS

Often the first suspect for junior developers whenever some mysterious error appears. Never mind that everything was working perfectly fine yesterday. It's probably CORS!

11. The Browser

An obvious one. I mean, is it OUR fault that people still insist on using Safari???

12. …And Eventually, Themselves

Now, let's get a bit more serious for just a moment. There are two kinds of complaining. The first is just harmless grumbling, the same way we complain about bad weather. It's particularly popular in countries like Poland, where complaining is practically a form of small talk.

But there's another kind. Of course, I'm not talking about situations where a project or the people you work with are genuinely toxic. Those situations absolutely exist, and sometimes you really do need to sit down and think about what to do next.

But in other cases? Sometimes it's worth stopping for a moment and asking ourselves where WE fit into this picture of everything and everyone we're blaming.

There's actually a well-known psychological phenomenon called the fundamental attribution error. In simple terms, it describes our tendency to overestimate someone's personality or character and underestimate their circumstances when explaining their behavior.

There's also a closely related concept called the actor–observer bias, which describes a tendency to explain our own behavior in terms of circumstances while explaining other people's behavior in terms of their personal characteristics.

And that's particularly interesting here. Think about what happens when WE mess something up: our code isn't exactly a masterpiece or we missed a deadline. We can usually come up with perfectly reasonable explanations. And often, those explanations are completely valid!

Maybe we were feeling a little sick, so our productivity dropped. Maybe the plumber wouldn't stop talking, and we lost half the morning. Maybe the library documentation was terrible. A million things could have happened.

But what happens when ANOTHER developer messes something up? What do we think? Unfortunately, quite often, it's simply: "What an idiot."

But here's the thing. That other developer has a life, too. They have their own problems, crying children, plumbers who show up late, and a thousand other things going on that we know absolutely nothing about.

We don't have access to their thoughts or their circumstances. So our brains take a shortcut. And suddenly, instead of thinking "maybe something happened," we decide that the person is simply incompetent.

And that's the thought I'd like to leave you with today. I was going to add some profound, philosophical conclusion here, but everything I came up with sounded suspiciously like something written by Sylwia Coelho.

So let's keep it simple. Let's just try to be a little more understanding toward one another. ❤️

And next time you find yourself blaming another developer, remember: somewhere out there, another developer is probably blaming you. 😂

If you enjoy my content, you can also follow me on LinkedIn.