The 10x developer is 10x overrated

We have probably all met this developer. The type that builds a new programming language as a weekend project. The type who genuinely enjoys Haskell. The type who can speak in three different abstraction layers in the same sentence. The lone genius who can do the work of ten engineers; the 10x developer. And honestly, for a while, I considered myself… not exactly that, but someone aspiring to become that.

But then I was assigned to improve the performance of a module. A module so perfectly “clever”, so deeply abstracted above where normal humans operate. The git blame told the story: this module had been engineered for (and effectively by) our company’s infamous 10x developer. And I had been dropped right into the dragon’s nest. I found myself asking questions every ten minutes. And every answer I got required multiple re-reads. Not because the explanation was wrong, but because it was operating on some higher plane of abstraction that I had to decipher like an Enigma message. Needless to say, I was at best 10x slower finishing that task than the infamous one.

This experience changed my perspective. Instead of aspiring to become another infamous company go-to genius, I realized the value of understanding what the rest of us are struggling with. Code that only one person can understand is not brilliant. is a liability.

Consider yourself a 10x developer, a founder of a new exciting SaaS product (preferably with “AI” in the title). Your product is fast, configurable and outshines the competitors. But eventually, you have to hire. And eventually, you will hire someone like me: a good engineer, just not you. So what happens when your ultra-clever, highly abstract, galaxy-brain architecture meets the reality of onboarding a normal human being.

They stare at your code.
They ask questions.
They feel slow.
You feel slow.
You get frustrated.
They feel stupid.
Eventually, they understand it.
And then the cycle starts over again with the next new hire.

One might argue: just let the 10x developer build the critical parts, and let the rest handle the simple tasks. But that approach creates bottlenecks, and more importantly, it is extremely risky. 10x developers often get 10x more job offers. And when that developer leaves (and they probably will), the company is left with questions no one can answer. Like a vibe coded codebase, you are better off building from scratch again.

Let me present a fun experiment. Wouldn’t it be interesting to embrace the -10x engineer. The inexperienced junior. The fresh eyes. The unbiased brain. Instead of optimizing your codebase for the most brilliant person in the room, optimize it for the least experienced engineer. Instead of designing code for the genius, design it for the person seeing it for the first time.

Why not take it a step further? Instead of hiring based on who writes the cleverest solutions, hire based on who writes the most understandable ones. Not because we want mediocrity but because we want maintainability. Not “less smart” but more collaborative. One might argue that a skillset like that is more valuable.

The most valuable skill is not being 10x faster, It is being understandable.The real 10x impact isn’t writing code only you can maintain. It’s writing code everyone can.