Software Developers Aren't Special

Software engineers tend to be smart people. Writing software is hard, and it’s entirely a discipline of exercising your brain cells to write the correct commands to make the computer do what you want it to do. Add in the layers of complexity that come with dealing with humans who want software to do something without necessarily knowing or understanding precisely what they want, and what you end up with is a fairly complicated practice.

There are many things that make writing software inherently difficult: it’s easy to mess it up, there’s a lot of complexity, the abstractions we use are often flaky and poorly understood, and everything is a moving target because the whole platform is constantly evolving both above and below wherever your project happens to be in the stack.

The Ego Blind Spot #

Software engineers do have one huge blind spot: their egos are often much larger than they should be. If you read comments on Hacker News, you’ll quickly get a sense that people who write software and frequent web forums like HN think quite highly of themselves and their intellect. They’re not entirely wrong, it’s true that you do need to be smart to make decent software. However I get the sense that a lot of these people grossly overestimate their own ability to understand and synthesize all the information in the world.

I’ve witnessed this phenomenon repeatedly:

• Engineers confidently explaining economics to economists
• Programmers lecturing medical doctors about how healthcare should work
• Developers who’ve written a simple machine learning algorithm presuming they understand consciousness better than neuroscientists
• Tech workers dismissing entire fields like sociology or psychology as “not rigorous enough,” despite never having studied them

Admittedly, I think in my younger years I was one of the computer people who believed I was smarter than I really was. It didn’t help that throughout my youth people often called me smart, and it wasn’t unusual to be praised as a “genius”. It wasn’t until I became older and realized that while software appears to be magic from the outside, it’s actually just a bunch of instructions that a machine follows which can start to provide illusions of intelligence once the complexity grows large enough.

Why This Happens #

This inflated sense of intellectual capacity doesn’t emerge from nowhere. Several factors contribute to the “engineer’s ego”:

1. Immediate feedback loops: Unlike many professions where feedback takes months or years, code often provides immediate validation. Write something that works, and you instantly receive positive reinforcement.

2. Creating worlds from scratch: Software development allows you to build entire systems from nothing. This god-like creative power can be intoxicating and distort your sense of capability.

3. Technical jargon as social currency: The ability to speak in complex technical terms that most people don’t understand creates an artificial barrier that can be mistaken for universal intellectual superiority.

4. Pattern recognition transfer: Software engineers excel at recognizing patterns and solving puzzles, which leads many to assume these skills transfer perfectly to completely unrelated domains.

5. Financial reinforcement: The tech industry’s high salaries implicitly suggest that software skills are more valuable than other professional abilities, further inflating egos.

6. Homogeneous environments: Many engineers work primarily with other engineers, creating echo chambers that reinforce the belief that their way of thinking is superior.

The Reality Check #

The truth is that software development is just one type of expertise among countless others. A brilliant programmer might struggle to:

• Design a structurally sound bridge
• Diagnose a complex medical condition
• Navigate international diplomacy
• Teach a classroom of eight-year-olds effectively
• Create meaningful poetry that resonates emotionally
• Understand the nuanced cultural context of a sociological phenomenon

Each of these domains requires its own form of intelligence, developed through years of specialized education and experience. The skills that make someone an excellent coder don’t automatically make them an expert in unrelated fields.

Humility as a Superpower #

Ironically, recognizing the limits of your expertise actually makes you a better software engineer. When you approach problems with humility, you:

• Listen more carefully to domain experts
• Build solutions that better address real human needs
• Collaborate more effectively with teammates
• Make fewer assumption-based errors
• Continuously expand your knowledge rather than assuming you already know enough

Some of the most effective senior engineers I’ve worked with are those who readily say “I don’t know” and approach new problems with curiosity rather than presumption.

Breaking Out of the Bubble #

The point of this post, I suppose, is to remind folks to keep their egos in check. Perhaps I’m just writing this as a reminder to myself. There are plenty of good ways for software engineers to get reminded of how unspecial they are, and usually the easiest way to do that is to go engage in activities with other people that don’t involve computers.

Try:

• Taking a class in something completely unrelated to technology
• Volunteering with diverse groups of people
• Reading books from disciplines far outside your comfort zone
• Finding hobbies where your programming skills offer no advantage
• Building relationships with people who have no idea what you do for work

The most grounding experience is often failing at something that others find easy. Nothing humbles a programmer faster than watching a skilled carpenter effortlessly accomplish a task they find impossible, or seeing a teacher expertly manage thirty children’s attention spans.

In the end, software development is just one skill set among many. Being good at it doesn’t make you special—it just makes you good at writing software. And recognizing that limitation isn’t a weakness; it’s the beginning of true intellectual growth.