This is a mobile version, full one is here.

Yegor Bugayenko
22 January 2019

10x Paychecks for 10x Programmers

You most definitely have heard about 10x programmers. The gist of this folklore is that some of us coders are very effective (10 or even 100 times more so than others), while the rest are just “normal.” It is definitely not a myth though.

Robert Glass in his Frequently Forgotten Fundamental Facts About Software Engineering (2001) essay said that “good programmers are up to 30 times better than mediocre programmers, according to ‘individual differences’ research.” I don’t know where he gets the number 30 from, and I seriously doubt this number makes any sense, but the bottom line is valid: there is a huge distance between people who just write code and those who do it right.

Steve McConnell in his blog post analyzed a few studies of this subject and demonstrated that the actual ratio varies from 2.6 up to 8. At the end of the post he asks “Have you seen 10:1 differences in capabilities between different individuals? Does 10:1 even cover the range?” Thus, the distance exists, it is pretty big, but, obviously, we can’t claim an exact factor.

But that is not my point.

What I’m interested in is the pay gap between those 10x programmers and everybody else. Let’s take a look at the salary report from PayScale (I took this screenshot from here):

According to this report, the worst programmer gets $36K, while the best one gets $100K, which confirms the 3:1 ratio. It’s far from 10:1, but if we look more closely, the salary of $100K is far from being the best on the market. For example, Indeed says that in Silicon Valley senior software engineers make $160K, which gives us the ratio of 4.4x. If we look even closer, we will see that some programmers make $250K or even $3M, which gives us the ratio of 83x. It seems that 10x programmers exist and they are paid according to their extraordinary talents—many times more than their colleagues.

Wait! Are they really?

It seems that the ratio we just observed is motivated by location instead of skills. The $36K programmers are not working together with $250K guys in the same office, committing to the same code base. This is just not happening. I can’t really prove it with statistics, but let’s hear from some companies. Basecamp: “Everyone in the same role at the same level is paid the same.” Buffer: “Master: 1.3X, Senior: +5%.”

Simply put, companies attempt to minimize the spread in order to avoid jealousy between programmers. Buffer made a big splash in the news, when they opened their salary calculating formula. This is not typical for the industry.

Even with ratios much smaller than 10x, employers tend to keep salaries secret. According to some studies, “about half of American employees in all sectors are either explicitly prohibited or strongly discouraged from discussing pay with their coworkers.”

Putting all this together we can effectively assume that no matter how large the difference in skills between regular programmers and 10x programmers in the same project, they will get almost the same, or very similar, compensation. In order to get more, a programmer has to change location, company, or both.

It seems very wrong!

And it’s not resolvable, until we change the payment model.

If we continue to pay programmers for their time, the pay inequality will always hurt. For me, as a programmer, it will always be difficult or impossible to understand why I’m getting, say, $100 dollars per day, while another Java developer is getting $1,000. I will be jealous and no team building exercise will be able to calm me down.

However, when we start paying by result, what seems to be utopian now, will become possible: 10x programmers will collect 10x paychecks. A good programmer will get $250/hour, taking home $25,000 a month, working part-time. A bad programmer will make $20/hour, taking home as much as … an average plumber, a bus driver, or an electrician.

A good programmer must make $25K+ a month, working remotely and part-time. This is how I see the future and this is what Zerocracy is leading us to.

In order to achieve that future we need to pay per result. This is the key success factor. Until then, there is no hope that those office slaves who claim to be 10x programmers will ever make what they truly deserve.