There's another reason, too -- which is that a "50x engineer" will very rarely be 50x on most development tasks.
Your 50x engineer may be able to build a highly performant and complex algorithm by themselves, truly in a week where other engineers might take a year.
But 99% of programming isn't that. It's CRUD apps and configuration files and debugging browser quirks and hunting down race conditions etc.
Your "50x engineer" probably isn't going to be all that faster solving a CSS bug or putting together an online order form or configuring Apache.
So even if companies could identify programming geniuses... they mostly don't have genius-level work to give them, so there's no use in paying 50x anyways.
In my mind and experience, a "10x engineer" (not sure I'm ready for the "50x" term) gets (or should get) that distinction because they write high quality, fault tolerant, secure, performant, well documented code, AND they empower their teammates. It usually has very little to do with the speed in which they accomplish all of that, which I think is why management has a hard time identifying who they are.
They may think the engineer who fixes 10 bugs a week is their best asset. But what about the engineer who quietly created high quality code with very few bugs, that's extremely easy to maintain?
A "10x engineer" gets that distinction because their software provides dividends in quality and maintainability for years and years, even if the initial implementation took them a seemingly long time. But management often just sees the engineer who's closing the tickets the fastest, even if that person's code becomes a curse on the company for years to come.
It doesn't help that so many teams are focused on 2 week sprints and quarterly goals. That kind of work favors a certain type of engineer, and incentives short term solutions.
I appreciate what you're saying... but I don't think that's the generally accepted meaning of 10x. You're just describing a good, responsible, effective programmer. Skills like good documentation or secure code are things anyone can learn from training and experience. And the qualities you're describing are also very much a function of what the company requires/expects/incentivizes, rather than what any individual chooses to do.
People generally reserve "10x engineer" who really do have the intellectual capacity and stamina to crank out 10x the amount of code of the same quality as a median engineer.
As far as I can tell, it's mainly the ability to hold a lot more "connections" in their head at any one time, and extreme logical rigor.
So that instead of reasoning about just the function they're writing, they're always naturally reasoning about the entire framework it fits into, and so they don't tend to produce bugs where the function doesn't fit in right, where it has weird side effects, where it duplicates code elsewhere, where it will create unforeseen technical debt, etc.
And then their logic is just watertight, always. They don't make all the kinds of basic design and logic errors other programmers tend to repeatedly make.
They sit down, crank out 1,000 lines in a couple of hours, try to compile/run, fix bugs around mismatched braces and misspelled variables, and it just works.
In contrast with someone else who takes a couple days to get it even kind of working, then winds up having to rewrite large parts of it twice because they'd made basic design errors in the first place.
But I still stand by my original point that most programming jobs don't require you to write a tight 1,000 lines often. Most work is plumbing, bugfixes, CRUD, etc. where the connections/logic skills don't really pay off in a big way.
There’s a bit of Amdahls law here: If I’m “10x engineer” but just 10% of the day, that means I’m really a 1.1x engineer. And it doesn’t matter (much) whether I’m a 50x or 100x engineer in that 10% the max speedup is limited by the “1x” part.
I agree that 10 engineers can’t do everything 10x. Even 10x engineers can only let 10% of the code 10x faster, it might have a deciding impact on the end result. if a software product is all written by 10x engineers, it might turn out to be 2x as fast as the one done by average engineers.
And in software optimization, speeding up a program 2x usually requires 10x more resources. This is why I think the 10x concept still makes sense here.
Without remarking on the whole 50x thing, I do think it’s worth pointing out that lots of software people don’t work on web development or CRUD apps very often.
People are overcomplicating this. It's simply because there is no market to create price discovery. Most of your price is established the day you start, well before you've proven yourself to be a '50x engineer'. And no one outside the org knows you're a '50x engineer', so there's no competition trying to hire you away. I am surprised the author of this article missed this despite making the analogy to sports athletes who have constant price discovery because their stats/accomplishments are public. It is in the company's advantage to prevent this price discovery and ideally not have a '50x engineer' be aware of how financially significant their contribution is, definitely not make competitors aware.
I think it's also very hard to even just be proven to be a 50x engineer even within a company. And most companies don't know how to identify 50x engineers. And yes even if they can, they have totally no incentives to disclose this info to other companies to increase competition. But for the most part they don’t have to block this info because they don’t know it in the first place.
> so there's no competition trying to hire you away
I agree with a lot of what you said but this part isn't true. I've been in conversations where people were bragging up that they were able to hire away Person X after >2 years of convincing. It definitely felt like know a guy who knows a guy though, not some open market.
That has less to do with the engineers themselves and much more to do with the benefit that those companies get from those engineers. Someone making minor UI changes at Google might provide a 5% increase in ad clicks in certain situations, which earns Google millions in additional revenue. Even though the bar for that kind of work may not be very high, most companies simply don’t get that much benefit from a single engineer, even a 50x-er.
It's rare for FAANG to pay over $1m total comp for an individual contributor unless you're a renowned superstar.
There's probably thousands of ICs at those companies who have delivered millions in recurring value, though. At Google scale, a single engineer could deliver 8 figures in value or more.
If you want to extract 50x you'll need to be a people manager. And in my experience, most 10x+ engineers are really bad at leading people. It's hard to be amazing at engineering and amazing at people management.
Professional sports salaries benefits from a game with well defined rules winners and losers systems of measurement around scoring points.
A company has a bunch of other stuff that had to be in solid alignment to "win". Engineers have to be working on the correct problems to begin with to add exponentially more value.
It's not as simple as "crushing" the sprint points assigned rather chosing the problem set ... If chosing the problem set then it's leadership or founders which can be rewarded at 50x.
It can still be difficult to tease out how much of any win is due to a single player, I think maybe the key difference is that the games are played in public and only one team can win a game.
So I, as a team owner, can watch Strasbourg pitch, see him nullify my lineup, then I have almost all the information I need to know he really is a lot better than average.
Additionally, by being willing to pay more and getting him on my team I'm depriving my opponents of his talent.
There is no direct analogue in programming, besides maybe open source projects.
In sports in a game the better team will win and the worse team will lose. In economy the better company will win and the worse company will also win, just a little bit less.
> “In software, the difference between the average software developer and the best is 50:1; Maybe even 100:1.” Steve Jobs
> If you’re a software engineer, you would probably agree with what Steve Jobs said.
I am and I don't. I've yet to see even a 10x engineer. I've seen people who are more than 10x within a very narrow domain, but when you include the whole system and all their responsibilities, no one comes close to 10x.
SW development is not just coding. The other aspects of it are harder to scale in performance. Amdahl's Law is very relevant here.
This is a gross misunderstanding of both software and amdahl's law.
Amdahl's law just states that the serial parts of a program stays the same as more cores are used for the parallel parts of a program. This also means that the percentage of time the serial part takes becomes larger as it stays the same and the overall running time goes down. It is not an incredibly mind blowing or insightful observation.
It is also assumes certain aspects can't be split up.
Multiple programmers means more communication (synchronization). If anything amdahl's law is an argument that having less but better programmers is much more effective than having more average programmers.
- Other stuff that may seem bureaucratic but nevertheless are essential (paperwork, tending to CI, tending to HW, etc).
This stuff (or at least some of it) is harder to scale. You can scale up the coding part quite a bit, but the overall process of SW development is held back by the above. You're not going to find someone who is 10x when it comes to talking to customers. Often managers will find the so-called 10x programmer and assign him to duties to maximize output, and have someone else do the work above. But he's still not a 10x overall, as he is simply not doing the work of other developers. That's why I said "within a very narrow domain".
Now if you can get a 10x developer who can scale all aspects of the job, then sure - pay him/her 10x.
This shows another huge misunderstanding of "amdahl's law". Again it is a very simple ratio.
Programmers who are much more effective are that way due to a lot of reasons you are missing. Amdahl's law is about programs that have parts that must be done and must be serial.
Great programmers are doing a lot less. They aren't wasting time with all the things you wrote here because what they make works, doesn't break, scales, and doesn't need to be changed while being much simpler. If you look at the source for doom, it doesn't have huge amounts of class hierarchies and ridiculous plumbing from bloated frameworks. John Carmack didn't go down a bunch of rabbit holes to procrastinate getting things to work. He isn't wasting time communicating with customers (why can't someone else do this?). He doesn't need to waste as much time with documentation because what he does is simple and works without needing to be changed. Not only that, but someone else can do most of this too. Tests are the same way.
The mistakes here are thinking that you have to waste a good programmer's time with nonsense and that they are trying to do what the average programmer is doing faster. The average programmer is terrible and is perpetually pushing their boulder up hill because they don't understand what is happening with what they write. They don't understand what will be slow, what is already simple, what has already been done etc. They create nonsense that is always being redone like someone trying to build a new house out of cardboard every time it rain because other materials are 'too heavy' or 'too expensive'.
> I've seen people who are more than 10x within a very narrow domain, but when you include the whole system and all their responsibilities, no one comes close to 10x.
In a company I've worked for, the "bests" were given the projects with mostly clean slates, and were rewarded for coding quickly, meanwhile the other developers struggled to integrate everything together and refactors were often frowned upon "to not waste time on the delivery of the project". And of course only "the bests" were authorized to work on those new clean slates projects. This gave rise to a very nasty positive feedback cycle where none of the original devs remained at the end of the project.
But it is true that the actual bests are 5 to 50 times more productive. I've seen it mainly with specialized consultants. Need to fix your tool chain? You can be sure that the build master consultant will be worth every pennies to fix those obscure C++ linking errors. Need to patch the kernel and even send the patch to Linus? Again, I wouldn't be surprised if you get a 100x ratio compared to a mid seniority dev who never did that.
From my experiences, the high productivity ratio between low end devs and high end devs stem from the multiple multiplicative factors that goes into making programming more efficient. Knowing how to automate repetitive work with scripts, typing fast and having a good knowledge of the appropriate tools and frameworks will help each other exponentially.
Those levels of total comp are mostly in stock. Stock compensation has a non-trivial level of luck in it. Join the company at just the right moment (knowable only in hindsight) when the stock is lower and then keep vesting as the stock skyrockets.
BTDT but I don't pretend it's my magnificent skills (although I'm good), it's just the luck of the draw with stock compensation. I'm just as good in other jobs where the stock performance has been lackluster.
Either you're in the value stream making (or saving) money for your company or you're someone that was added because some manager said they needed headcount. If you can't tell which you are, then neither can HR or upper management.
2) Sometimes 10x or 50x or whatever Nx is not really what it's thought to be.
I've had to deal with the aftermath of some "10x" engineers and it's not always pretty. Now you can say that this just means we aren't measuring properly, and the person wasn't really 10x (more like -100x in fact, that minus before the 100, in case you missed it, is for "negative" as in negative 100x) but there are still people around thinking this person was 10x, because they still think highly of the elaborate and tightly integrated ongoing catastrophic disaster fountains he planted in the code base.
But then... yes there are some real 10x engineers. Again this is misunderstood though. I think many people can be 10x (or 50x) engineers, depending on circumstance. It's not always about the person. It's the right context plus the right person.
The right circumstance + the right person can make someone 50x. It appears to me the ability to identify circumstances and people and put them in the right place is also very important? It might be another 50x worth thing.
Paul Graham wrote an long essay decades ago that basically says if you want to be paid what you're worth, then work in the context of a small company. http://www.paulgraham.com/wealth.html
I read this article before and I think this might apply to a 5-10 person startup. An engineer’s ability might be easily measured there. But the problem is startups at that scale usually don't have that much money to pay engineers. That’s probably why you see the reverse.
The author suggest that star athletes are paid for their exceptional athletic ability.
Star athletes are paid for their ability to fill a stadium and or sell advertising/media rights. Part of their value is their celebrity and name/likeness. They are more equivocal to entertainers in this context. Of course, ability matters, because winning teams are celebrated!
Software developers do not bring this value to their organizations.
Not really true, with few exceptions you have to deliver on the field of play as a star athlete to maintain a high salary. The marketing creates some variance within the category but the top paid athletes are the top performing athletes otherwise why would they even retire?
I would argue that making efficient and reliable software products is a very crucial factor for a software company to bring more revenue. It’s just not as straightforward to measure this.
When Microsoft got into compilers, they were giving $1m signing bonuses. [1] There's also the concept of acqui-hire. On the other side there is price-fixing [2]
1. Mr. Gross quit in September but didn't join Microsoft until after a three-month sabbatical to plan his wedding, Borland said. According to the suit, Microsoft also offered Mr. Hejlsberg a $1.5 million signing bonus, a base salary of $150,000 to $200,000 and options for 75,000 shares of Microsoft stock
> If you’re a software engineer, you would probably agree with what Steve Jobs said.
No. I don't. I do believe that Jobs was being hyperbolic.
This article would seem to imply that most managers are 0.1X:
> In fact, you can see how hard it is to evaluate a software engineer from the process of big tech companies. The most common technical interview process for programmers is to ask them to solve very challenging programming questions.
Your engineers are already solving very challenging programming problems. If you can't work with that, you shouldn't be in management. Part of your job is to evaluate skills and compensate accordingly. If you can't manage that, you are a 0.1X manager.
What strikes me as odd is that SaaS companies want to sell subscriptions to software. But they pay employees a one time fee (in the form of a salary often) for code that may run for 5 years or more in production.
If the company fires the engineer, the engineer doesn't gain any further profit from the code he wrote.
because the 15x programmer that is slowed down to 1.3x because the 50x added 80x of technical debt will leave the company. So the company will only have 50x that leave as soon as there is a need to fix their own code.
To put a real value on the work of a heterogeneous pool of developers is way harder than it looks. One will only value the contribution of what 'he/she' values as important. But the quality of a software come from the strength of many that focus on different things. Even the person who is not really good, but is the only one that bring a 'team spirit/team work' brings value to a team.
> The challenge is that to successfully cash out, ALL the pieces of the company have to work together and effectively to some degree.
In theory, yes. However if you look at Google and FB a lion's share of their revenue is through ads. Yet they employ thousands of engineers and pay them extremely handsomly to chase all sorts of projects and moonshots most of which are inconsequential.
My favourite hypothesis is that they keep the smartest engineers hand-cuffed in gold and ask them to dig-a-hole-fill-a-hole just so that they don't go somewhere else to build a competing product. They succeed by and large. In India for instance a small/medium startup has no chance in hell to match Google's total comp, let alone other perks. Not only is cash and RSU handsome but also they get yearly RSU refreshers. The kind of money Google pays just blows my mind.
There is not a straightforward way to measure it. It’s highly domain dependent. There are some general directions though. Deep understanding of domain knowledge, clear logics, excellent programming ability, and ability to frame a problem in the right way and break it to smaller problems. It’s vague I know, that’s why it’s not trivial to see it though.
Another way to view this is that programming sometimes is like solving a math problem. A top-tier mathematician can solve a difficult math problem 100x faster than an average person. 100x is even a bit understatement because most people can’t even come up with any solution given long enough time. For sure, programming is not solving math problems, but they have some similarities. But this is a way to conceptualize it.
Lots of pushback in this thread against the idea of 10x, 50x, etc. engineers. If we’re just measuring performance relative to the average software developer then I don’t see why they wouldn’t exist. I’ve met developers who solve problems that the average developer would simply never solve no matter how much time they threw at it. You could make the argument that they are “infinityx” engineers, as silly as that might sound.
I do feel that. Another way to view this is that programming sometimes is like solving a math problem. A top-tier mathematician can solve a difficult math problem 100x faster than an average person. 100x is even a bit understatement because most people can’t even come up with any solution given long enough time. For sure, programming is not solving math problems, but they have some similarities. But this is a way to conceptualize it.
https://danluu.com/bimodal-compensation/ covers this to some extent. There is a pretty wide distribution to SWE salaries. SWEs who really want those 10x salaries can aggressively pursue high salaries and get 10x the median SWE salary if they hit T7-9 at a FAANG: https://www.levels.fyi/
> For example, one of the top MLB pitchers, Stephen Strasburg, received $38M in 2019, while the average salary in MLB was $4.3M.
This isn't the right comparison. If Strasburg is the number #1 baseball player in the world, it makes sense for him to max 10x the median MLB player who would be the ~500th best baseball player in the world. I'm sure the #1 best paid programmer in the world easily makes 10x - 1,000,000x the median programmer when you account startup equity.
And people who aggressively jump between FAANGs at high levels can get $1M+ offers and counteroffers.
Around 5% of MLB players can get $20M a year, which is around 5x to the average. But I am not sure there are 5% of engineers at the Bay Area can more than $1M
Idk have you ever considered because the boss wants to minimize costs and paying engineers 50x (or even 2x or w/e) isn't the norm in the industry so they don't? Chalking it up to "it's hard to evaluate" seems to be missing common sense.
The article alludes to this but maybe doesn’t point it out clearly enough: they can only minimize cost in this way _because_ it’s hard to evaluate - otherwise the engineers in question would just work somewhere else where their value would immediately be recognized.
I think the real 50x engineer is a person who is a strong engineer, also does design, innovates, and can build a business like a CEO. That person could actually bring 50x value to a small org.
It might be hard to build an unicorn with a single super developer. But he/she might build a great product to get the company enough funding to grow to an unicorn.
Your 50x engineer may be able to build a highly performant and complex algorithm by themselves, truly in a week where other engineers might take a year.
But 99% of programming isn't that. It's CRUD apps and configuration files and debugging browser quirks and hunting down race conditions etc.
Your "50x engineer" probably isn't going to be all that faster solving a CSS bug or putting together an online order form or configuring Apache.
So even if companies could identify programming geniuses... they mostly don't have genius-level work to give them, so there's no use in paying 50x anyways.