This is a very insightful list. But there is one thing I'd quibble with: while it's inherently a super-subjective metric, I would say that 10x programmers do exist. Both in the "can support a company by themselves" sense and the "mad lone genius" sense. Not all the 10x programmers are good at working with other people or on other people's ideas.
0.1x programmers are often lost or afraid, although they may just be unimaginative. The real risk of fear is introducing 0.1x processes. People are often willing to sacrifice any amount of development velocity to avoid being seen to make mistakes.
Sometimes this makes sense, sometimes it doesn't. Arguably the reason for the success of SpaceX is that they were willing to fly, crashland, and improve a dozen rockets in the time that a conventional company would spend agonizing over whether to launch at all. On the other hand, nobody wants to be on the same roads as the "move fast and break things" self-driving car.
Saying 10x programmers are a myth because it's crazy that someone could do in 1 day what another could do in 1 week makes the assumption that both programmers in the example have the same amount of context, background understanding, and experience.
The benefit of talented engineers comes from the fact that they avoid costly pitfalls - not that they pump out more code per hour worked.
I feel this "10x programmers are a myth" attitude comes from a good place of wanting to promote harmonious working and skill-up junior engineers, but it seems so totally detached from reality. I'm not sure the "benefit" of propagandizing against talented assholes is worth the cost of demotivating people who might be inspired that they could become a 10x engineer.
Realistically, I’ve always found it a weird sentiment more because issues caused by software developers are not of the “this person is 1/10 as productive as this other person” type. A bad developer isn’t a low positive effect on a project, but an active negative effect. As such, you can put literally any Y for a (Y)X programmer, since the scale of how inefficient a programmer can be goes up to infinite.
I think the pushback against 10X programmers comes primarily from the fact that many programmers who look good to managers (constantly push out new features) are in actuality an albatross around the necks of the other programmers who constantly have to fix the messes they create (in reality, a negative on team-wide production). What matters more to me in a teammate than how productive they are is to ensure that they are on the positive side of the scale at all, which the perceived 10X programmer is often actually a failure at.
Though I’ve definitely met people who just have such a wide knowledge base and think so quickly that they are in fact 10X as effective as a standard productive programmer, so I do understand where the idea comes from.
> In 1988, the Soviet newspaper Komsomolskaya Pravda claimed that the widely cited achievements of Stakhanov were puffery. The paper insisted that Stakhanov had used a number of helpers on support works, while the throughout was tallied for him alone. Still, according to the newspaper, Stakhanov's approach had eventually led to increased productivity by means of a better work organization, including specialization and task sequencing
Exactly the same discussion, except there it was tonnes of coal which can be easily and unambiguously measured. But they can't be easily attributed. How much of his work was really that of his team? And how much of it was simply inflation by his managers for propaganda purposes? And how much of it was, underneath all the propaganda, real process improvements?
TAN: I fearst heard of "Stachanovism" over forty years ago, in my teens. Some time before that I had read an anthology of American folk tales, so to me Comrade Alexei Grigorijevitj was always kind of a Soviet version of John Henry. Made it easier, when I later found out, to accept that Stachanov was also at least in part a myth...
At the same time, if one compares shoveling coal and laying bricks with software, then it'd be good to smash and destroy bricks, throw the coal back into the mine, raze houses. (Reducing the amount of code)
Software would be more comparable to designing the coal mining site, or architecturing a city (but not building it). And then maybe it's simpler to see, that individuals sometimes can have much impact.
> The benefit of talented engineers comes from the fact that they avoid costly pitfalls - not that they pump out more code per hour worked.
Not just avoid pitfalls, being able to put together a good architecture is a huge factor as well. The effect is cumulative. If you have a good design to begin with, everything becomes easier with less risk of bugs. The result is that implementing new, or changing existing functionality takes less time.
The 10x developer doesn't write 10x as much code, (s)he will probably write less code than the 1x developer.
Exactly. It's not how fast someone churns out code but how well thought out/elegance in approach that delivers this 10x value.
Instead of writing entire systems from scratch, maybe you have enough experience or familiarity with well known techniques and libraries to ship faster.
It doesn’t matter if I have better experience or I can contextualise intent better; the phrase “10x” means it would take a team of 10 to do it, in the time, scope, budget (whatever).
But there are major reasons this could be the case, if I’m on my own and I know the direction then I don’t have to quibble about what framework to use, how to name my variables, what I consider “proof of concept quality”. You just get your head down and do it with the entire scope and progress in your head at once.
No infighting about semantics, no deeply technical progress reports or trying to subdivide tasks which are not inherently subdividable.
More people is more communication and it’s quadratic.
> Saying 10x programmers are a myth because it's crazy that someone could do in 1 day what another could do in 1 week makes the assumption that both programmers in the example have the same amount of context, background understanding, and experience.
Yes, because that's how it's always presented. And if it's not, then it's also a myth because then it's not a 10x dev, it's 10x context, background understanding, and experience.
> it's 10x context, background understanding, and experience.
A person who is able to build 10x context, background and understanding is a 10x developer. Most people lack the ability to do that. Your post makes it seem like you could give those traits to anyone easily, but it doesn't work that way building the right mental models and being able to generalize your knowledge are key factors in talent.
Why do people need to be motivated in such a way? Won't that just lead to a lot of disappointment and misery later on? Why isn't "being a good programmer" something we should admire?
Of course one programmer can create 10X the code of another. The limit isn't how fast they type. Its how correct the code is, and how much it leverages what you have and what you'll need. And that results in 'pumping out' more code per day. Whatever the reason (context, background, experience)
Yes but I think the underlying issue is that some people really Really don't like to acknowledge (or are unaware) there's a small set of elite programmers that can do things average coders can't. But any label we use to describe them (i.e. "10x", "rockstar", "ninja", etc) will be psychologically distasteful. I previously commented about that effect:
To see that hidden psychology driving the narrative... look at how the author constructed his comparison with extra qualifiers of "competent" & "similarly experienced" : ">The idea that someone can produce in 1 day what another competent, hard working, similarly experienced programmer can produce in 2 weeks is silly."
In other words, if we artificially construct the comparison by a priori assuming both programmers are equal, then the 10x difference is a myth. Well yes, that's tautology.
If you invent a sentence to "prove" a point, you can set any conditions in the artificial universe in your favor that seems to support it.
However in the real world, the stack of resumes will have a candidates with wildly different skill levels. Some struggle with Fizz Buzz. Some can write a 3d game from scratch. But it's impossible to create a label to describe that wide gap which also doesn't invite bikeshedding on that label.
EDIT reply to: >"Why can't we call them master programmers?"
Because we'd still have endless bikeshedding of the label "master" as in "Master programmers are a myth..."
We don't call Vermeer a 10x painter, Beethoven a 10x composer, nor Shakespeare a 10x author. It would be silly to call Turing a 10x computer scientist, or rockstar and ninja would be insulting.
Vermeer, Beethoven and Shakespeare are masters of their crafts. The same word we use for skilled tradesmen. Why can't we call them master programmers?
People typically call them geniuses, not masters. And the reason we don't call them genius programmers is that people don't like to use the genius label for people who aren't famous.
A master craftsman will solve a problem quickly, efficiently, and elegantly, combining insightful attention to detail with speed and effectiveness.
A master creator will produce work of lasting relevance and power. The metric is quality and impact, not speed and efficiency.
Occasionally you get people like Mozart who combine elements of both, but they're exceptionally rare. And they work best in a relatively limited context which they have mastered completely. They're not perpetually chasing the latest shiny. (Mozart basically knew one style. Even he would struggle to master all the languages and genres that are common today.)
Turing would likely have made a poor backend developer, but he produced work that had lasting impact.
A typical 10X developer will be more like a master builder than a master computer scientist.
I don't find the labelling offensive, because it's clearly realistic. Some people are just very, very good. They produce clean, tight, code at speed, far more quickly than muddlers who produce reams of mediocre code which creaks along, breaks when you look at it, and doesn't actually solve the problem.
But a 10Xer isn't going to be good at everything. If they mostly do backend, they're not going to go toe to toe with game devs. Etc.
I think part of the reasoning is in the trades there's the presumption that to be a master you must also be old (with exceptions, Da Vinci was active when he was still younger, 20).
In the programming industry, there's likely a bias more toward younger people, and hiring offices ask for the world. They'd like a whole staff of masters and rockstars. Though that doesn't preclude "older" people from being known as masters either. Take John Carmack or Jonathan Blow, for example.
That is a interesting thought, that seems to imply that those young programmers will not improve. If you are a master at 25, what do you call yourself after you have gained twenty more years of experience? It may be that those 25 year old's a more like journeymen then masters, or that programming is more like sports where youthful vigor are more important than experience.
John Carmack programmed Wolfenstein at 21 and doom when he was 22. At that point he did what most "masters of that craft" couldn't do. What would you call him? And what would you call him now, 30 years later?
> And what would you call him now, 30 years later?
Something else than thirty years ago, because presumably he has developed since then.
I think that was why GP suggested "journeyman" for younger people, because otherwise there's nothing to differentiate young "masters" from masters honed by thirty years of additional experience -- except adding the whole phrase "with thirty years of experience", which is pretty clumsy.
How many times faster is an O(n) algorithm over a O(n^2) squared algorithm?
How many times faster is a developer who can write a compiler over one who can not?
We are at least consistent; I rather frequently see programmers claiming a "105 times faster!" benchmark that was actually the result of a fundamental complexity change.
I once worked on a team that in hindsight had two 10x developers in a team of only 12. They were vastly different, and the difference to me is extremely interesting.
The first one was not a bad person by any means, but had no social skills, no ability to communicate and often just forged ahead building great stuff on his own. Entire areas of the software were entirely conceived and created by him, and it was difficult to even grasp what he was doing while pair programming with him. In a day he would write more tests and get more coverage than the rest of us would create in a week.
The second one had come from a FAANG-ish place where he was extremely successful, but didn't want the money or stress. He was extremely kind, considerate and great at communicating. Pair programming with him was a joy and he helped everyone else on the team grow. I'm confident he could have created entire regions of the software on his own, but he knew that wasn't the right thing to do. He would often ask questions until someone else on the team could solve a problem, even though I'm sure he knew how to solve it easily himself.
Yeah the first one is a risk. I've met one whom I had to take over the code of when he left and psh, I wished he was a dumbass instead. He could produce shitloads (but would never test, interestingly), do stuff I honestly can't do, but do you really need to bitshift instead of doing a modulo to save 1 CPU instruction ?
The amount of obscure waste of programming complexity made us actually just abandon the thing he spent years on to just not do it. And everything works fine and we still make money and we're just probably a little bit less clever about how we do it. We also have a lot more time to listen to users and solve their problems, rather than gloat on our genius and solve our own created problems :D
Your second example is inspiring and I hope to meet one to learn from too !
My go-to examples of 10x developers are benevolent dictators like antirez (of Redis), evanw (of esbuild + Figma CTO), youyuxi (of Vue), Carmack, etc.
Both qualitatively and quantitatively, their output is at least 10x of a typical developer at a typical company, not even counting everything these people do besides writing code. Many more are not famous but are in the same league of impact/productivity - I'm genuinely puzzled how someone can say such people do not exist.
Bit of an aside, but writing an email is its own art. Not many developers know how to write an email that a busy, non-technical VP will read, understand and act on in the way they intended. (Then again, neither do many managers.)
You mix popularity with 10x. Not all 10x programmers are popular.
I believe 10xers exist within a business or technical context. This isn't limited to the field of computer science, but even traditional engineering (Edison) and sciences (Newton) have plenty 10x examples.
I'm not mixing - as I wrote, many more are not famous, but their impact is similar. When discussing abstract concepts, it helps to have concrete examples of that phenomena. Using "famous" people is a shortcut to define a shared definition for what "10x" might look like.
And yes, there are "10x" teachers, investors, lawyers, storytellers, sales folks, etc. Similarly, the distribution of talent that helps with "software development" might have a very long tail, leading to extraordinary performance versus the median.
IF 10x exist, some will be popular and most won’t. Obviously he won’t know the obscure ones or pick examples you can’t relate to. So while he didn’t prove his point perhaps, perhaps you didn’t disprove his either. :)
To pose it another way: for general software Dev (not some niche use case that only one guy understands), let’s say building websites in Vue or React, the idea of a 10x developer is that they can work in January and another, average, programmer can then spend February, March, April, May, June, July, August, and Sept… and the average guy won’t get more done?
Or they come in only every other Monday and contribute as much as a median Dev working full time?
It just doesn’t seem reasonable at all, at least if we read it literally.
I have worked with and met great, outstanding, developers who are much better than me. Some of them famous. None of them are anything close to 10x as productive, and I’m not particularly great. They’re much smarter than me, for sure, but they’re not 10x as productive.
How long would it have taken you or me to write Doom, or Quake? How long would it have taken Carmack, if it'd just been him?
I think you have a false dichotomy here. Carmack isn't 10x better a C or assembly than me. But in his domain he's easily 10x smarter and more productive than me.
And on top of that, he has a quarter century more experience in graphics programming than me. That shit accumulates.
Yes, actually. In graphics programming, from 2D and software rendered, to OpenGL and VR, you could give him and me (and presumably you) any task achievable in a few human decades, and he'd do it more than 10x faster.
"Graphics programming" is not a small niche, and yes in that space he's a 10x programmer.
I think you're thinking of this the wrong way. I agree that for something as simple as "build some websites", yeah, 10x is going to be very hard. You're then just turning specs into code, pretty much.
10x programmers are those that don't waste 9 months. The hard part is knowing which 9 months out of 10, which 9 ideas and components out of 10, is waste.
For "build a web forum" or something, yeah there are no 10x programmers. Though there are many many 0.1x programmers still.
> How long would it have taken you or me to write Doom, or Quake? How long would it have taken Carmack, if it'd just been him?
I'm not a games programmer. I doubt a median games programmer would take 10x the length of time that it would take any other games programmer. It just seems implausible, and I don't know why people want to defend it.
I spent 8 years at EA and was a senior software engineer. I have absolutely witnessed 10x game programmers.
I think in any field where you have a deep domain with complex, difficult constraints, it is entirely possible to have programmers with 10x the effectiveness of the median simply because of their greater domain expertise. They know the unique algorithms, data structures, design patterns, hacks, tricks, hardware quirks, tools, debuggers, code smells, etc. All of that has a huge compounding factor when it comes to output.
Here's a story I like to tell:
I joined EA shortly after the PS2 came out and worked at the studio that made Madden. Madden was a launch title on the PS2 (meaning it shipped right as the PS2 hardware did) and that version essentially sealed Madden's success. It was hugely successful.
But making a launch title is really hard. You're developing softare for a hardware platform that is itself in flux. When EA first started working on Madden PS2, they didn't have any dev kits to work on. I don't know if dev kits even existed. They needed to write code that they couldn't compile and run. But if they didn't start immediately, they would never be able to get the game done in time for the launch.
They had a guy on the team with a reputation for being a wizard. He took the MIPS R5900 reference manual, and disappeared into an office with blacked out windows for some number of weeks. When he re-emerged, he had written a PS2 emulator despite never having access to an actual PS2. The rest of the team were able to compile and run the game on that emulator so that they could make progress until eventually real dev kits arrived. From what I heard, when the real hardware showed up, the game actually ran on it.
Now, some of this legend may have grown in the retelling (it was already legendary by the time it was told to me), but I worked with that engineer a few times and I can vouch for his incredible ability to get stuff done. I remember once when FIFA was having performance problems and couldn't get their framerate high enough to ship. He was called into to help and a few days later, got it up to a solid 30 FPS. This was even though the team's own engineers had been trying to make progress and he had never touched the code before.
I think people dislike the mythos of 10x engineers because it's interpreted as some sort of cognitive essentialism. But I think most of it is just really deep domain expertise. Instead of talking about "10x engineers", we should talk about 10x at what.
The median games programmer wouldn't be able to do it in 50 years. (assuming they were locked in a room for 50 years with that same hardware, not that they got to see state of the art progress and upgrade their machine)
The amount of innovation, from applied BSP, Zbuffer tradeoffs, light maps with interpolation, interleaved FPU corrections for texture mapping, multiplayer protocols (qtest used TCP), brush-levels, etc...
Before ID software did these things, they weren't checkboxes for what to do. After, sure. But the hard part of programming is not typing.
The median programmer would not have been able to do it before it had been completely irrelevant. The median games programmer could do it in 2005. In 1993-1996? Not a chance.
The main competitor to Quake was Duke Nukem, which technologically was just "doom and a half". The enemies were sprites, ffs.
ID software was years ahead of every other games developer.
The reason other games licensed the Quake engine wasn't that it was cheaper than doing it yourself, it was that they couldn't do it.
Edit: granted, I have a low opinion of the median programmer. But sometimes in life you meet people who, with things you think you're actually pretty good at, just completely mop the floor with you without even trying (or showing off). It's humbling.
> I doubt a median games programmer would take 10x the length of time that it would take any other games programmer. It just seems implausible, and I don't know why people want to defend it.
Then why did all those thousands of other game programmers fail at creating a decent 3d game, before Doom was released? It's not like Carmack was the only one trying.
I think it's more likely that we wouldn't have thought something like Doom to be possible until Carmack came along and squeezed oodles of math tricks and hacks into the game to let it run on hardware of the era. So it may as well have be an infinitely long development time for us.
If you wanted to write Doom, starting in 1993, and take 10 years, your most efficient strategy would probably be to do something else for the first nine of them and wait for the technology to change around you.
Almost certainly you would just plain have not been able to do it at all. Not in 1993-1996. Not without it already having been done once.
And if you had, it would have taken you more than 10 years to realize what the right thing is, and to solve all very complex problems that showed up on the way.
Quake doesn't even have any load times! Not even with the hardware available at the time.
There is no "10X" touch-typist because a) the performance limit is absolute & relatively low and b) the learning curve is such that it's easy to get to the limit and plateau. Now let's increase complexity - still typing, but you must translate the text from another language. Increase again - now you're translating poetry. Increase again - the poetry is original Shakespeare. You need to translate into contemporary English approachable to Gen Z, as a script for a TikTok short, referencing memes from current events. There is no doubt that some people will have a combination of talents - in language, typing, copywriting, built-up cultural knowledge, lived experiences - that will make them 10X in such jobs.
The more software development work approaches touch-typing, the less difference between 1x and 10X — strict Jira tickets in, garbage out, maybe slightly faster. Spec-work, and most grunt-work, is undifferentiated and does not benefit from a 10X person. The more your work approaches poetry - such as exercising user empathy, improving the architecture, considering UX, respecting performance constraints, understanding user's jobs to be done, and improving your implementation around that - the more creative space there is for 10X to reveal itself.
Ironically enough your example is flawed: there are documented 10x touch-typists.
The realities of the court system place high demands on the typists; the minimum required typing speed is already quite high: trained court reporter or closed captioner must write speeds of approximately 180, 200, and 225 words per minute (wpm) at very high accuracy in the categories of literary, jury charge, and testimony, respectively[1] - and some exceed the minimum and go for 300 wpm. Even better, the official record for American English [is] 375 wpm [2].
Compare that to the average typing speeds around 30 - 40 wpm [3] Granted, the court reporters use specialized input devices (stenotypes) - but hey, the same can be said about highly productive programmers, who use specialized development environments - and sometimes also specialized input devices.
You make a good point that hints at another often-undefined assumption in these discussions - 10X performance vs who, exactly? IMO, it should be vs "a typical peer in that profession". For court reporters, if "a typical peer" is a trained court reporter who averages ~200 wpm, and a superstar is at 300wpm, then it's a 1.5X gain. If a "typical peer" is a regular Joe, then 300wpm would be 10X - but this doesn't feel appropriate because we compare productivity of a "10x developer" vs a "typical developer", rather than vs "an average Facebook visitor".
Even with drudge ticket-punching work, there is a vast spectrum of productivity between somebody who is capable and conscientious enough to do it correctly the first time and the person who has to rework everything multiple times because they can't do it right the first time and continue making mistakes.
That definition is too narrow. How about this one: can someone work for 1 year and (consistently) produce 10x more value for their organization than the median engineer? This seems transparently true if you've worked in any large organization.
-1x programmers also exist, in a variety of guises. From the dev with long cv of projects he’s contributed nothing to and been sidelined from, but who manages to keep getting hired because of his cv, to the dev who crowbars in new tech where it’s not needed and causes a ton of problems.
Presumably a 1x programmer is an average programmer. The type who does his job acceptably. He doesn't create huge problems, nor solve them. He is a fine team player and team member, but not a leader. Nobody despairs when he leaves, and he will be forgotten after a few months.
Now that I think about it, the worst code seem to lead to situations where the top developers can really show their value.
I mean if the code base is quite good and is kept that way, then a normal developer can deal with it quite well.
But if you get a legacy mess, then the hard-core developer can make really drastic changes that have enormous value to the maintainability, future development and bug-wise.
If a normal developer tries to tackle that mess, it's easy to get into trouble and drown in the sea of opportunities and not see the big picture and take a proper road plan to improve things.
So in a way -1 developers enable the top developers to show the gap between them and the normal devs.
This could be managers who deem themselves programmers or software architects. (Often they would use their authority to promote their ideas and effectively shut everyone else up.)
I've also met one 10x programmer in my life. A lot comes down to being able to reason fast, architect well, and write code on the fly without resorting much to:
* Documentation
* The debugger / print()
Becoming a 10x developer means that you have a set of skills that work well together in an end to end process from going to initial requirements to fully fledged architecture and/or code.
I think most people who have worked with me would consider me a 10x developer, I am capable of writing something in hours that would take others weeks (not in a half-arsed way, but taking all of the complexities of the domain into account). And I think that's what most people think a 10x'er is: that they can just do stuff quicker.
That's not what I think 10x'er is though. I think a 10x'er is someone who enables the 'average' developer to become a 2x, 3x, 4x developer. This can be through writing some core tech, a library used by all, or through mentoring and guidance. The 10x'er can then become a 100x or even 1000x developer. The 10x dev is the person who picks up the really difficult or ugly stuff and says: "Hold my beer, I'll get that done" - motivating the team and helping them to keep velocity. They lead by example and explain to the team why they've taken the approach they have.
Sometimes people use the term Rockstar to define a 10x developer. I think that's a loaded term that comes with an 'arrogance' tag. The true 10x developers shouldn't be arrogant (beyond the base level arrogance everyone of ability has), they can and should be the glue that holds a team together and helps everyone achieve more.
10x development: a person that does it 10x faster.
What you describe, I'd simply call a lead developer since making other developers 2x or more is a lead developer his job.
If you're a developer and you're doing this, then it'd be one argument to get promoted to lead.
Also, if you really are a 10x dev, the one I know works in the HFT space. He's making bank. I'm not sure if that's your thing, but I've noticed they seem to appreciate 10x devs a lot more than any other company out there (and that includes FAANG).
Leading by example is not necessarily the same as being a lead developer. For example, my principal engineer is easily a 10x'er as just a pure developer, but he's also a force multiplier for everybody on the team, he's literally a machine. He leads no one, I made him principal engineer so he didn't have to.
If he was to just write code he'd be a 10x'er, with the other work he does to help his colleagues, he's many times more than that.
In the fantasy organization where means justify ends, the 10x-er's time is
better spent making the 1x-er obsolete. Your lip service to the 1x-er however
does not go unappreciated as keeping him on and making him feel more
productive is instrumental for political advancement, which is more important
for your fortunes than the technical kind.
What an incredibly cynical view of the world. Teams where people collaborate are more successful, if you think trying to make your colleagues obsolete is time "better spent", I honestly feel sorry for your co-workers. Yes, if I sat and just wrote code all day I would get a lot done. But, if I help my colleagues too, we all get lots more done.
Yes, but some people generalize their experiences much much better and therefore can master domains and adjacent things to a degree others will never reach.
> Becoming a 10x developer means that you have a set of skills that work well together in an end to end process from going to initial requirements to fully fledged architecture and/or code.
The problem with that definition is that it tags the coveted 10x label onto the problematic cases mentioned in the article: that guy who is able to hack together POC code that he demos and passes off as the solution, but requires a whole team to fix and to rewrite and to rearchitect to get it to actually work and be production-ready and be maintainable.
Inadvertently, this means that we see the 10x label being tied to observable behaviors that are actually a productivity nightmare just because they go from zero to demo in record time.
Well, speaking honestly probably more like 5x, but it would take a solid 5 person team working well together to do the same things he did.
His ability to reason about the problem- get to the root of the persons actual issue, proof of concept intitial revision and iterate until it was better quality than most popular open source projects was honestly awe inspring.
His only problem was his own lack of self confidence. He used tools and always asked if they were really the best or if he was inflicting them, had good reasons for not using things that we consider industry standard (he prefers restructured text over markdown because it’s more expressive, for example) but was ultimately very sad about every project he made because he felt like he had inflicted his (good) work on the world.
So, idk. The people who think they are rockstars probably not. He definitely didn’t think he was but he was a god to me.
Disclaimer: I feel strongly about this. However, if you have a strong other opinion, then I applaud you and I'd be curious to read it. Rationally, I don't think this term matters a lot as there are better terms to describe programmers, but emotionally it's tied too much to a friend of mine and that's what makes me feel so strongly about it.
> The problem with that definition is that it tags the coveted 10x label onto the problematic cases mentioned in the article: that guy who is able to hack together POC code that he demos and passes off as the solution, but requires a whole team to fix and to rewrite and to rearchitect to get it to actually work and be production-ready and be maintainable.
As I said in another comment. I've met one 10x programmer. So I consider him to be the archetype 10x programmer since he's the only visible proof I have. We're good friends, we mostly talk about life. I sometimes see him code. Let me assure you, he is the last guy that would hack together POC code. I know this, because I'd be one of the first to do that and he gives me a lot of flack for that when I show it to him xD
I should have left out the "or" in my definition. He knows how to architect, he knows how to code, he micro-optimizes every nano, is capable of understanding how underlying ISAs are doing their thing. He knows how to reason well. At companies where he'd enter as a junior, he was immediately recognized for having better technical skills than people 10+ years their senior (note: not his social skills, those are simply normal).
They exist. And it's easy to see why 10x programmers exist. Take a bell curve of ability and you find many 10x'ers on many scales of ability.
Or would you argue that people like Einstein was not a 10x physicist, or that Euler wasn't a 10x mathematician? And there are many more that I wouldn't even know of.
10x programmer is very related to the idea of a genius, in my opinion. It's simply a subset of it.
Feel free to disagree. It's good to see other perspectives.
If their code isn't running in production with little maintenance required then they didn't actually produce the thing. Just add that requirement and it becomes clear.
So there are these moments in development, where the task boils down to ‘I just need to build this system. I can see it all in my head, and I need to turn it into code’
And for that task, factors like how well a developer knows the libraries, how fluently they can express themselves in the language, how fast they can type, how seamlessly their mental model fits with the tools available.. all of those things can make the difference between it being something one dev can crank out in a couple of days, and another dev takes a few weeks over.
And I definitely want more of the first kind of dev on my team than the second kind.
But here’s where that doesn’t match up to what we expect of lead developers and more senior devs as their careers advance, and why ‘10x’ is not necessarily an indicator of ‘ready for promotion’.
The person who can see the whole problem and turn it into code in 2 days often struggles to figure out how to scale what they do to more people. They can’t express how the code should work to someone else because they’re already three steps ahead - explaining how it needs to be done will take longer than just doing it!
So the problem is as soon as this person encounters a problem that is too big to fit all in their head and crank out in a few days, or that requires expertise they don’t yet have, so they need to collaborate… the approach they have learned to rely on stops working.
But it turns out there are 10x team leaders too - devs who can break large projects up into chunks that can be delivered separately, who make sure the team is building the right thing, who know how to make use of that individual who can just crank out a complex system in a couple of days - repeatedly and sustainably - and who make systems that are the right shape so that later features are cheaper and easier to add, rather than becoming harder and slower. In fact at this level the multipliers go way beyond 10x.
And some of those skills build on the individual 10x dev skill set but some are orthogonal to it. Some are downright opposed.
I like to say that I am a 10x developer 10% of the time. My work tends to be very "bursty" followed by long bouts of low productivity. It probably has more to do with my mental health than anything else. :/
My personal joke about this is "I used to be a 10x developer but then I took an arrow to the knee".
Many, many years ago a colleague wrote about the experience of being bipolar and choosing to stop taking the lithium for a temporary productivity boost and subsequent crash.
There can be that. But also some managers do not like you wander off task. So stick in your lane stick to your tasks... So eventually after years of that you just do only what is needed and skip anything else. After a few of those 'that is very nice but...' conversations you just say screw it and coast. Every once and awhile I get a burst where I can propel my group forward. But then usually I feel like I am bolder chained to them and dragging them down. More than likely I am just average and doing OK.
> The idea that someone can produce in 1 day what another competent, hard working, similarly experienced programmer can produce in 2 weeks is silly.
Over such short time scales, maybe, but the idea that someone could contribute in 1 year what another programmer wouldn't accomplish in 10 years is highly plausible, to me.
Also, sometimes it isn’t someone ‘moving fast and breaking things’ - sometimes everyone else gets paralyzed with indecision and can’t even get started.
Someone who can sit down and start coding in an ambiguous environment, period, can easily make 10x more value themselves, and allow others to go from .1x to 1-5x merely by being able to pick somewhere to start and just doing it, which allows everyone else to break their own ‘freeze’ and start engaging as now there is something concrete that breaks the locked up state they were in.
I’ve done it a few times, and seen others do it to. It’s magic going from ‘everyone rehashing things on a whiteboard for the 10th time’ to ‘everyone working on the next iteration’
The "MVP" or "strawman" is incredibly valuable; people can't tell a blank sheet of paper what they want, but if you show them a thing they'll tell you what's wrong with it.
I've noticed myself that I can happily write detailed comments on HN or StackOverflow but have no inclination for blog posts, for that kind of self-content-marketing that seems to be popular these days.
>sometimes everyone else gets paralyzed with indecision and can’t even get started.
I once worked on a project where exactly that happened, and I view it as one of my biggest failures of my career. I often wonder why I didn't just sit down one day and type int main( ...
and just get on with it.
In the end the project got canned and both contractors terminated early, so I made sure that never happened again.
I'm not claiming to be a 10x developer or anything like that, but I have a related story to share:
Once I had to tweak a 7000 line signal generator (ie spits out wav files) written in Java. It had a mind boggling structure, and I'm sure whoever wrote it was a mad genius of some kind.
I rewrote it in less than 100 lines of Python, where each signal primitive was basically a few lines of code max, which you can functionally combine.
Since this new program was not even 100 lines long, we were able to do a LOT more with it, and in a super flexible manner.
And then you encounter the 10x programmer, who is not afraid to throw the bullshit code away and write it in a way that is easy to manage for other devs. I'd say this is really a more realistic example of a 10x programmer. Most programmers are just afraid of asking the "why" question and the actually acting if there is no good answer.
> while it's inherently a super-subjective metric, I would say that 10x programmers do exist
Even worse than super-subjective, it seems like people don't agree on the definition of "10x programmer".
Is that 10x value (code * code quality) produced per unit of work-time? Per brain cycle? Are you controlling for programmer experience, or domain knowledge, as [1] pointed out? Do you actually mean 10x, or is that a stand-in for "significantly more productive" with an unknown value? Do you include collaborative skills and working with a team, or even entirely base your definition off of that?
I'm both curious as to the exact definition you have in mind, and also trying to point out the more general issue so that others arguing past each other can realize that they have two different ideas in mind.
Have a 1 year project. One side is a team of 10 developers with 5 years of experience in the field. Other side is 1 developer with 5 years of experience in the field. Do you think it is unreasonable that there is any developer that could beat the team in that situation? The quality expectations for both are the same, so no shortcuts.
I don't find that unreasonable at all, most teams are very unproductive. So what I'd call it is "A 10x developer is a developer who can outperform a typical team of 10 developers".
For me, it's definitely "a stand-in for "significantly more productive" with an unknown value". Neither the input nor the output can be properly quantified, and we don't really know the full set of variables to control for, and it inevitably runs into serious questions of inequality, SES, and background that are likely to make people even more cross.
I see it as more of a compliment. Nobody should be seriously and unironically calling themselves a 10x programmer, it should be bestowed by other people.
People are often willing to sacrifice any amount of development velocity to avoid being seen to make mistakes.
IMO that attitude never makes sense - it can make sense to avoid certain mistakes at all costs (self-driving car), but it never makes sense to try to avoid blame for them (company refuses to admit their car isn't good enough).
This is a problem of culture, not individuals.
Does the culture at a company openly admit mistakes, try to learn from them, and put systemic fixes in place to address them, or do they punish people for mistakes?
If the latter, you end up with nobody admitting to mistakes and a terrible culture, it's not about the people, it's about the situation you have put them in and the incentives given to them.
No, it's also a matter of personality. One manager used to urge me to do things in half the time at 90% of quality, and stop chasing the remaining 10% at such high opportunity cost. To this day, I try, but it's hard to overcome a natural, obsessive tendency.
> it can make sense to avoid certain mistakes at all costs (self-driving car), but it never makes sense to try to avoid blame for them
Eh? As you say, it's a culture thing, and the culture of a lot of humans is that the mistake only matters if you take blame for it. Plenty of people and organisations put more effort into avoiding blame for things than the thing itself.
Blame-free culture is great, but it has to be actively maintained.
Plenty of people and organisations put more effort into avoiding blame for things than the thing itself.
Blame is pointless (particularly directed at humans), learning from mistakes is invaluable. What I'm saying is it is a terrible mistake to put more effort into avoiding blame than avoiding mistakes.
Blame-free culture is great, but it has to be actively maintained.
0.1x programmers are often lost or afraid, although they may just be unimaginative. The real risk of fear is introducing 0.1x processes. People are often willing to sacrifice any amount of development velocity to avoid being seen to make mistakes.
Sometimes this makes sense, sometimes it doesn't. Arguably the reason for the success of SpaceX is that they were willing to fly, crashland, and improve a dozen rockets in the time that a conventional company would spend agonizing over whether to launch at all. On the other hand, nobody wants to be on the same roads as the "move fast and break things" self-driving car.