from Hacker News

The Myth of the Myth of the 10x Programmer

by payne92 on 2/17/20, 6:37 PM with 219 comments

• by remmargorp64 on 2/17/20, 9:12 PM

  10X programmers DO exist. They aren't just a myth, and they aren't just about knowing when to buy vs build, or when to use a particular framework or toolkit, or how to "mentor" other developers.

  Chris Sawyer wrote 99% of the code for RollerCoaster Tycoon in x86 assembly language, with the remaining one percent written in C.

  RollerCoaster Tycoon was a beautiful game which still stands the test of time to this day. The fact that a single person was able to build a blockbuster-level game almost entirely by themselves in assembly is a truly impressive feat which very few programmers would even dream of undertaking.

  Being a "real" 10X programmer is like being a savant. It's about being FUCKING SMART, and it's about being able to deliver a working, polished product in the same time that a normal team of ten people would be able to deliver it (or in a tenth of the time that a single person might).

• by jimbokun on 2/17/20, 10:12 PM

  Here is your 10x programmer:

  https://norvig.com/sudoku.html

  "In this essay I tackle the problem of solving every Sudoku puzzle. It turns out to be quite easy (about one page of code for the main idea and two pages for embellishments) using two ideas: constraint propagation and search."

  If you gave this task to an "average" developer, how long would it take for them to implement? How many lines of code would it be? Would the implementation be correct? How long would their code take to execute?

      % python sudo.py
      All tests pass.
      Solved 50 of 50 easy puzzles (avg 0.01 secs (86 Hz), max 0.03 secs).
      Solved 95 of 95 hard puzzles (avg 0.04 secs (24 Hz), max 0.18 secs).
      Solved 11 of 11 hardest puzzles (avg 0.01 secs (71 Hz), max 0.02 secs).
      Solved 99 of 99 random puzzles (avg 0.01 secs (85 Hz), max 0.02 secs).
  

  Does the average developer know what "constraint propagation" and "search" mean in the above sense, or remember enough about them from their CS class to recognize them as the right tools and how to implement them?

  Also, can the average developer implement a spell checker from scratch on a single transcontinental flight?

  https://norvig.com/spell-correct.html

  So Norvig is always the paradigmatic example of the 10x developer, for me. Having a broad range of CS techniques at your disposal and knowing how and when to deploy them, is almost a super power.

• by amznthrowaway5 on 2/17/20, 9:15 PM

  > highly productive developers (10x or otherwise) are problem-solving at a much higher level

  This is a very important point, but calling these highly productive developers "10x" doesn't really make sense. They are more like "infinity times" compared to the average when it comes to getting a difficult task done, since the average developer would just get stuck and never be able to invent good designs and solve the difficult problems. Even worse, some programmers are in the negative on many tasks, adding additional complexity and overhead while making little to no positive contributions, especially when you give them a problem beyond their capabilities.

• by marcus_holmes on 2/18/20, 8:13 AM

  I think part of the objection to 10x programmers is around expectations, self-assessment, and attitudes.

  There are people out there who have difficulty working with others. Some of those people feel that this difficulty is because they're so FUCKING SMART and the others are morons who are beneath them. They're extremely difficult to work with in a team environment, but come across as completely confident about their own abilities.

  These people are toxic to work with. They drag everyone else in the team down (part of the reason they are productive is that everyone else has to spend time and effort dealing with their bullshit).

  Management should spot this and deal with it. But in a lot of situations the "10x" has managed to get into a position where they have a lot of information that the rest of the team doesn't have (deliberately, usually) and getting rid of them would be difficult. And some managers buy into the whole myth as well, and having a toxic "10x" on their team that they have to carefully manage is a point of pride, or something.

  This archetype, the lone genius developer who is 10x everyone else, is extremely appealing to some people. Regardless of their actual ability, they start believing that they are this. And worse, behaving like this.

  So while, yes, there are some programmers out there who are very productive, the majority of self-proclaimed "10x programmers" you're actually likely to meet are just socially unaware assholes with inflated egos.

• by hardwaregeek on 2/18/20, 7:15 AM

  Y'know, productivity is kind of overrated. The programmers who I admire aren't the people who could implement a React CMS in record time, but the people who built React. Or Rust, or Haskell, or FFmpeg. I guess one could argue that the programmers are 10x, 100x or even (10^n)x simply because their work has helped other programmers become more effective, thus through the multiplier effect resulting in massive productivity. Or because you need someone who can work at 10x to build something of large impact. But first, that just means that Large Impact => 10x, not that 10x => Large Impact. Second, that's oversimplifying a massive, nuanced impact into a number for no real reason.

  Honestly I suspect the idea of 10x developers was created as a way to explain to managers why you need to pay ol' Leslie over there the big bucks. If you claim Leslie works at 10x the speed and only needs 2x the salary, the math works out for a business major. So I guess that's the reason you need the number.

• by gilbetron on 2/17/20, 9:28 PM

  The concept of the 10x programmer seems to have been drifted from its original meaning. It isn't that there's a coder that is 10x better than a good coder. It is that a lot of people are really bad at their jobs, and a coder that thinks and learns about problems can be far better than those people. It comes from terrible "corporate drone" software developers in the 80s and 90s - the ones that would takes weeks to developer simple routines. Bring in someone that loves software dev, and they appear magical.

  Today, with Google and Stack Overflow, that gap has diminished, but there is definitely people still way better than "average" developers. However, if you have someone that keeps their skills sharp and their problem solving desire sharper, you won't fine anyone 10x - maybe 2 or 3x, at best.

• by WalterBright on 2/17/20, 9:29 PM

  I personally know many programmers who are easily 10x average programmers. No question about it.

  They crank out code that is easy to read, easy to understand, works right out of the box, and gives years of trouble-free operation.

  Sean Parent is one of those programmers. It's pretty obvious when he describes how he replaced a nightmarish tangle of code that re-invented a simple rotate algorithm.

  It's a remarkable talk:

  https://www.youtube.com/watch?v=W2tWOdzgXHA

• by nybblesio on 2/17/20, 9:56 PM

  The OP's example is perfect: he didn't go to the leaf-nodes and write each test by hand. Instead, it was clear that writing a tool to do the job would be better. Software is all about leverage. This is what defines a 10x programmer.

  However, I'm constantly amazed how many programmers fail to see the forest for the trees.

  To a large extent, not seeing (or seeing and ignoring) this type of solution is learned behavior. Many environments are hostile to this world view. Writing tools (especially those that generate code...eek!) is seen as "over-engineering" and "unnecessary complexity". If you're in a factory, on a line, your job isn't to climb away from your leaf-node.

  Any programmer has the potential to be 10x, they just have to see and act upon it. Few do.

• by CognitiveLens on 2/17/20, 9:57 PM

  It's worth pointing out that the research found a 10x _spread_ between the least-productive and most-productive engineers - a '10xer' isn't someone who does ten times more than the average, so it becomes less mythical if you think about someone who does, e.g. 2x more than average in an organization with a few burned out engineers doing 20% of the average.

• by BXLE_1-1-BitIs1 on 2/17/20, 9:59 PM

  I remember one programmer that I characterised with "He writes a lot of code". I ended up with one of his not small routines that I replaced with a one page assembler routine in MVS NIP rather than OPEN.

  When reworking printing software to support multi color, I researched a commonly used subroutine though several layers of calls and replaced it with, yes, a single character constant.

  I lost count of the many legacy applications where I tossed out great gobs of code produced by "productive" programmers.

• by petilon on 2/17/20, 10:24 PM

  10x programmers do exist. But here's the thing: its not worth being a 10x programmer. Managers don't necessarily want them.

  First of all, if you complete a project 10x faster than the expected time, managers will assume that they had overestimated the project, as opposed to recognizing that you're a 10x programmer. I have seen this time after time after time.

  Secondly, if a manager does recognize that you're a 10x programmer then you will be seen as a risk: what happens if you leave the company? If the product was built by a team then that's a legit business. If the product was built by just 1 person then that's not a legit business as the business can suddenly collapse if that 1 person leaves.

  Third, you make your co-workers look bad by raising the expectations bar. You will not win any popularity contests. You may make your manager look bad too, if your performance diminishes the value of the manager.

  If you're indeed a highly capable programmer here's my advice: don't be a 10x programmer by doing 10x the quantity of work or completing projects in 1/10th the time. Instead be a 1.1x programmer, then expend your remaining energy helping your teammates grow, and broadening your influence. (So scale yourself horizontally instead of vertically.) This advice is often not easy to heed if you're introverted, and if you're extroverted you are already a manager instead of a programmer.

• by e1g on 2/17/20, 9:21 PM

  I think we instinctively recognize the outsized levels of certain pros: a 10x leader that is a different creature from a typical manager, or a captivating writer that is 10x better than the average novelist, or a 10x actor vs a standard-issue LA newcomer, or a 10x teacher who inspires far beyond what curriculum mandates. Can we accept 10x lawyers, coaches, artists, or musicians based on their impact? We do, and we seek and celebrate them. Why fashion designers but not app designers, why essay writers but not program writers?

• by Eridrus on 2/17/20, 9:09 PM

  One thing I have observed recently is the existence of "10X projects".

  This might be a symptom of working at a big company, but I have been really impressed by the ability of some projects to achieve their ends while others get stuck in quagmires due to the fault of nobody on the project per se, but rather the definition of the project itself.

• by 1e-9 on 2/17/20, 10:27 PM

  Harder problem => Increased productivity variance

  For extremely hard problems, it's not difficult to measure greater than 10X differences between highly-talented senior developers and the average productivity of those capable of meeting requirements.

• by dustinmoris on 2/18/20, 9:57 AM

  This whole 10x programmers debate is tiring. Why do we even argue over such a dumb thing? OF COURSE THEY EXIST. That is not even debatable. It's a fact of life that there are people who can achieve more than others. It is the case in sports, in politics, in school, and not surprisingly also in tech.

  You have football players who play their entire life and they don't progress beyond a hobby team and then you've got the likes of Christiano Ronaldo and Lionel Messi.

  The question is does it give a 10x dev a justification to behave like a dig? No, it doesn't. You still have to be a good team player, just like in a football team a 10x player won't perform well if he/she is pissing off the rest of the team.

  So can we stop debabting about facts of life and just get on with it?

• by ccheever on 2/17/20, 9:41 PM

  I think the way to think about this is that there are some people who figure out ways to do things or invent things that just wouldn't be figured out or discovered by other people.

  So, it's not 10x or anything-X even, it's just that, if the stuff that can be uniquely provided by "10x" people is important to you, then you need someone like that. 10 1x developers aren't likely to give you that (except to the extent that you have 10 chances to discover that one of them is actually a 10xer on some dimension).

• by bloody-crow on 2/17/20, 10:31 PM

  I think team sports is a good analogy here. There's no people who are 10x stronger, or who can run 10x faster than their teammates, but there's certainly people who'd score 10x points in certain circumstances than anybody else, and that is what 10x programmer is about.

• by mikekchar on 2/18/20, 2:57 AM

  The reality of the situation is that rather than 10x programmers, there are actually 0.1x programmers. Frequently you will have teams that are so burdened by whatever hurdles are in their way that they produce only a tenth of what they could be producing. Interestingly, there are programmers who self impose those hurdles. There are programmers to impose those hurdles on others as well. Quite frequently, though, the hurdles are either imposed from afar, or occur as a result of unfortunate decision making that has accumulated over a number of years.

  A real "10x" programmer is a programmer who is able to unshackled themselves from the burdens that turn them into 0.1x programmers. Beware, however, because many of these people achieve their productivity at the expense of others on the team. Indeed, there is a special breed of programmer who will inflict 0.1x burdens on the rest of the team precisely so that they can appear to be a 10x programmer.

  I once worked on a team of 5000 programmers, where the average number of lines of code produced per programmer per day was 1. We can all argue that KLOC per month is a terrible productivity measure. However when your productivity is around 20 LOC per month (without the K), there is something seriously wrong ;-) 0.01x programmers (at best)????

• by t0astbread on 2/17/20, 9:45 PM

  It doesn't matter whether 10x programmers exist. Programming is not a sport and as such, competition will only lead to narrow thinking, useless optimization and hatred. What we should really strive for is making programming a more creative activity where people learn from and inspire each other, not a competition.

  Oh and also, "finding the 10x engineer" feels like a hotspot to inject hidden bias into recruiting.

• by koonsolo on 2/18/20, 9:25 AM

  I've been a 10x developer compared to my yesterday self.

  I needed to add a feature that required a big rewrite of my framework. This would take maybe 2 weeks.

  The next day I realized I could support that exact same user benefit with only a few lines of code.

  Sometimes just looking at the problem differently, or sleeping over it can have a huge impact, not only compared to other developers, but also to yourself.

• by yodsanklai on 2/18/20, 7:22 AM

  > I think 10x developers, like world-class athletes, musicians, and authors, absolutely do exist.

  For this question to make sense, one should give a better definition of what constitutes the output of a programmer.

  In a sense, there are Nx programmers for any arbitrary N because some developers can build things that other can't.

  But we can't reduce the work of a software engineer to "programming". Most "programmers" today aren't developing some new hobby systems from scratch (it's the easy part IMHO). They work in the context of a team, they have to deal with legacy code (possibly boring, using technologies they don't like), they write doc, review code, discuss designs and solutions, they give talks to present their work, they train or supervise colleagues, they interact with difficult managers or colleagues and so on...

  In that context, I wonder how "star programmers" operate. I wouldn't be surprised if some of them are even under-performers.

• by thoman23 on 2/17/20, 11:09 PM

  A few people have touched on it here, but I'll add my voice. I firmly believe that there are programmers who are better described as a "1 vs. 0" programmer. Some programmers have a creative talent in them that leads them to create elegant solutions that literally a team of 50 average programmers would not.

• by gandalfgeek on 2/17/20, 9:47 PM

  If you look at the original paper (going back to 1968) where the data for a 10x difference was first found, there are a ton of... issues.

  I've covered this in detail here: https://www.youtube.com/watch?v=Gho89X72Xas

• by oarabbus_ on 2/17/20, 10:55 PM

  There are 10x salespeople, 10x authors, 10x basketball players, and 10x scientists; why should there not be 10x programmers?

• by overgard on 2/18/20, 12:03 AM

  I agree with the article, but I also think it leaves out something fairly important, which is minimizing huge time sinks. Instead of being 10x better, how can you reduce wasted time 10x?

  I remember working with this one guy that was light years smarter than me, but if you watched him use the IDE it was painful. He did everything in the menus, slowly. How much of his life could he have back from memorizing f5 and a couple other shortcuts?

  Maybe you could reduce waste in various ways:

  * Learn keyboard shortcuts instead of pecking through menus

  * Use search instead of browsing (especially with keyboard shortcuts!)

  * Have you ever lost half a day debugging something that turned out to be dumb? (I have!) Is there a way to modify your coding style or your testing habits so you never hit that again?

  * Do you know your stack well enough that (given the time) you could reimplement the same ideas yourself? (Or is it a magic box that you can't debug? How much time and effort do you spend prodding the magic box?)

  * Have you automated all the manual things you currently do?

  * Are you wasting a lot of time dealing with bad abstractions when something much more basic would suffice?

  * Are you mastering your tools/languages/frameworks, or are you switching around so often that you spend a lot of time looking things up?

  * Do you have input into how your tasks are written, or are you stuck with whatever breakdown someone else came up with? Is your work getting awkwardly twisted to fit into these milestones? Can you work out a better system with your leads?

  That's the tip of the ice berg -- I think if you look at almost anything you do, you can generally find some aspect of it that's cumbersome and wasting your time. I feel like when you account for wasted effort/time, and removing it, becoming "10x" starts to seem a lot more reasonable -- it's not about being a genius, it's about being introspective and careful about how you perform your work. It saddens me to say this, but I think that sort of introspection is rare. I see so many programmers doing uncomfortable awkward things every day, because it's only like 10 extra seconds, except those 10 seconds times 20 times a day times a year and now that cost is out of control

• by slowhand09 on 2/18/20, 4:27 PM

  They are rare, but definitely out there. I've worked with one, managed one, never been one. One charateristic I observed over these 2, they'd take a manual home and read it over a day or two. They'd retain most of it. They tend to be touch typist not needing to look at the keyboard often. This reduces context switching and lets them flow when they are being creative. They know and remember syntax, library routines and interfaces so they aren't stopping to look things up. They "try on the fly", fail fast and often, and move to alternatives when blocked. The ones I know I'd love to start a company with. But I would be the bottleneck...

• by NohatCoder on 2/18/20, 9:54 AM

  I don't know if there is truly such a thing as a 10x programmer, but I have no doubt that 0.1x programmers exist in hordes. Even people who at small scale seem competent can often end up making a complicated mess when dealing with bigger projects.

• by kunglao on 2/18/20, 11:10 AM

  Considering how software development has become relatively lucrative and so many want to throw themselves at this, it's bound to create a large pool of incompetent engineers. Specially because this isn't an industry that is regulated like medical doctors or architects. Given that, I think it should be relatively easy to find 10x performers on different teams.

  However, to find a 10x guy in a high-performing team, that'd be a sight :)

• by keanzu on 2/18/20, 1:11 AM

  If we take a simple application of Price's law:

  The square root of the number of people in a domain do 50% of the work.

  In a group of 121 the top 11 are doing 10x the work of the other 110.

• by helsinkiandrew on 2/18/20, 8:44 AM

  The best way to carry 8 gallons of milk across a muddy field in a leather bag is to leave it in the cow.

  I never assumed that the 10x programmer was actually writing 10x the amount of code in the same time but instead knowing how to do something in a 10th of the time, with less risk and cost (by a using a better algorithm, novel approach, or 3rd party package etc).

  It's the difference between being a developer and a programmer

• by SideburnsOfDoom on 2/18/20, 9:42 AM

  > I developed them in 3 days, by writing a C program to automatically generate the range of tests.

  So they were 10X at that task. Are they like that, consistently, all the time? Maybe next time it's another person's turn to have the insight on how to drastically simplify the task.

  This is not "10x people" at all then. This is a "10x day" or a "10x week" in a fairly normal person.

• by nhumrich on 2/18/20, 1:56 AM

  I find that I am a 10x developer when I compare myself to other versions of myself. I have had days where I honestly feel bad because I got almost nothing done, and other days where I get a ton done. If I was able to correctly channel my focus and effort, I would be 10x then I used to be. Now sure, maybe the time spent not as focused allows me to have those bursts of productivity.

• by chx on 2/17/20, 9:49 PM

  I'd argue today a team could be 10x. Yes it requires someone who knows the concepts and can effectively communicate them but also awesome project managers, designers and QA personnel. A great team (I am lucky to be part of one) functions like a well oiled machine churning out acceptably quality features and fixes the problems at a surprising rate.

• by sunstone on 2/18/20, 12:54 AM

  To make an analogy with the ancient Roman trieme ships with three tiers of rowers. A 10x rower in that context is not the guy who can pull the oar 10 times harder, it's the guy who, while he can pull the oar, can also tell you when the ship is on course because he knows how to navigate and thereby makes everyone's effort more efficient.

• by DantesKite on 2/17/20, 11:35 PM

  Despite the differences in definition, reading the comments on this page has been lovely. I’ve enjoyed the many perspectives.

• by noicebrewery on 2/18/20, 1:43 AM

  The author of this article is a 10x self-promoter for using a hotly debated precept to humblebrag about his accomplishments.

• by liamcardenas on 2/17/20, 9:29 PM

  Why wouldn’t there be such thing as a 10x programmer? Is the average programmer so good? There are outliers in every industry. Professional athletes are a clear example — they are often many orders of magnitude better than the average player of their respective sport.

  There are probably also a few 100x engineers, maybe someone like Elon.

• by whateveracct on 2/18/20, 3:16 AM

  If you're really 10x and you're giving that 10x to some company and not getting 10x value, you're doing yourself a disservice! Either get fair value (probably won't happen) or give them less than that 10x and use your spare energy for other pursuits (relaxing, entrepreneurship, art, hobbies, etc)

• by d--b on 2/18/20, 9:22 AM

  He’s saying 10x developers are those won’t don’t code 10 times faster the same code, but those who find ways to code 10x less for the same results. that I agree with.

  But then he compares 10x developers to world class athletes... That’s a bad comparison. The 10x developer is the guy who takes the bus instead of running marathon!

• by cmhnn on 2/18/20, 1:10 AM

  How does an industry so full of brilliant people who consider themselves much smarter than their users keep arguing in these absolutes about programmers like their skills are easily classified.

  Many things have become popular that were originally written like ass by someone who was better at making something people found useful than they were at data structures or thinking in big O.

  A lot of genius language design people are nearly useless when the whole messy world of shit like network, filesystems and interacting with things not their language is involved.

  Programmers being human also are not some consistent machines that constantly maintain some level of productivity regardless of what is going on in their personal life or their interests waxing or waning in a given problem space.

  The people whose code has changed the world are maybe a handful or two. So, astounding developers much better than most do exist. But even they are not some multiple of every coder for every problem.

  Nevermind, it's time to stop even thinking about programmers alleging truisms about programming and go get my MSNBC|FOX fix so I can get the necessary stimulus to knee jerk.

• by DonHopkins on 2/18/20, 4:08 AM

  It's not that Alan Turing was a 10x or 100x programmer (not that there were many others to compare him to at the time), but that he had a deep intuitive understanding of mathematics, which he could apply to many problems from different fields.

• by xornor on 2/18/20, 7:27 AM

  It is very easy to find -10x programmers, which proves that there are also 10x programmers. It depends on the reference skill level.

• by paulus_magnus2 on 2/17/20, 9:29 PM

  Can we stop the self hate already? There definitely are 10x musicians, 10x painters, sportsmen and 10x programmers. You know what never exists in 10x form? Burocrats and middle managers who write articles like this one.

  I suggest to flag this as fake news and all future articles intended to devalue young talented programmers who yet are to discover their true market value.

• by tanseydavid on 2/19/20, 9:11 PM

  10X programmers do exist but good luck finding them as Job Seekers.

  It is also a concept which is NOT SCALABLE.

• by xtf on 2/18/20, 7:46 AM

  Problem is the scale. Script kiddies and junior programmers are 0.1x to 0.6x or people reinventing the wheel by not using a framework, they could be far less and let's not talk about security. Experienced (senior) devs should be counted as 1x. Beside knowing to programming fast, they (should) know how programm more correctly.

• by _y5hn on 2/17/20, 9:23 PM

  What have the company done in the past 15 years to build a progressive learning culture?

• by bsaul on 2/18/20, 8:07 AM

  If you look at it the other way, is there any field where some pro aren’t 10x « better » than other pros, at least by some metrics ?

  In sport it’s pretty obvious there are, and you can measure it because there’s a « winner » and a « looser » at the end of each game. But i’d imagine it’s there in pretty much anything.

• by jpswade on 2/18/20, 8:18 AM

  Being a 10x programmer is not sustainable and doesn’t scale well.

  A great team is not made up of lone rangers and wild stallions.

• by wanone on 2/18/20, 1:52 PM

  10x programmer @ 1x pay

• by lincpa on 2/18/20, 2:15 AM

  If you use [The Pure Function Pipeline Data Flow v3.0 with Warehouse/Workshop Model](https://github.com/linpengcheng/PurefunctionPipelineDataflow), although the development speed will be a little slower, thinking will be a little more, but later reading, incremental development and maintenance will be less than ten times.

• by ten_xer on 2/18/20, 10:44 AM

  As a 10x programmer myself (NOT TO BRAG) I will tell you we definitely exist. My greatest annoyance is watching the rest of you peons crawl along at a snails pace while I am inventing the next groundbreaking technology that will completely flip your existence upside down. Perhaps the only person who could even understand my level of motivation is Elon Musk, but I'm not even sure if I would have the patience to explain it to him.

  It is a daily occurrence that while you are trying to find a missing semicolon that I'm already cleverly arranging your old commits using git rebase to turn your finger-painting into a Van Gogh. My only advice is just to get used to it, because we aren't going away. The best thing you can do is hope to get a management role so that you can be freed from the burden of competing with us. Let's be frank: most of us 10x programmers are on the deep end of the spectrum and therefore won't want or perform well in a management role, but for those of us that can, managing normal programmers would be excruciating.