Hacker News new | past | comments | ask | show | jobs | submit login
The Myth of the Myth of the 10x Programmer (payne.org)
248 points by payne92 on Feb 17, 2020 | hide | past | favorite | 219 comments



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).


> It's about being FUCKING SMART

It's not always about being FUCKING SMART, sometimes just having a different attitude helps.

I've worked with testers who refused to write code but would rather test everything manually (and fall behind on every sprint!), while stupid (yes), you could easily come in and be a 100X more productive by just writing tests as code.

For one company I worked for we had an old legacy system (running DOS) that we used to produce master copies of our disk images. When we needed a new master it would take the better part of a day to make all parts work. I wrote a program that could do what the legacy system did but under Windows, taking a couple of seconds to run and now we could get a master image as a build artifact. I don't consider myself FUCKING SMART, quite the opposite, especially at that company with those coworkers who were despite the sound of it actually really smart, but unlike my coworkers I had not accepted the situation but felt that there must be something to do to improve it.


> I don't consider myself FUCKING SMART, quite the opposite, especially at that company with those coworkers who were despite the sound of it actually really smart, but unlike my coworkers I had not accepted the situation but felt that there must be something to do to improve it.

This is the secret sauce. The impulse to solve the higher order problem and the willingness to question fundamental assumptions in order to arrive at a solution.

Your non-10x devs might have attempted to optimize the DOS system, or maybe even introducing some kind of caching and just lived with the somewhat mitigated performance.


I agree and have a similar story to yours about improving an old system. At a previous company we had a deployment process that took 1 developer 6 hours to complete. There was a 6 page run-sheet of manual instructions (create Windows image; log in and set these parameters; install this software; etc.)

I took a couple of days to automate the process and reduced the deploy time to something that could be done multiple times a day and didn't require a developer. Am I FUCKING SMART? No, but I was able to see the bigger picture and realize that there are tools that could be applied to this problem.


I agree they exist. The article does too, at the end:

...highly productive developers (10x or otherwise) are problem-solving at a much higher level. Their productivity won’t be apparent from a narrow test, any more than the overall skill of a world-class football player would be apparent from (say) how fast they could run the 100m dash.

The most productive developers are solving big problems, and are bringing judgment and experience to bear on essential design, architecture, and “build vs use existing library” decisions. They’re designing key abstractions that will pay dividends through the life of the project...


I think you're missing the point of the comment you're replying to. Yes there are developers who are more productive by working at a meta-level above normal, but there are also people who are just 10x more efficient at actual coding. Those are distinct concepts that may or may not overlap.


Not to diminish the achievement, but worth noting I think that RollerCoaster Tycoon was based on his earlier Transport Tycoon engine, so at least he did get to split the work up between two projects.

I have a personal theory the that the average 10x programmer is say 2.5x smarter than average, but also 4x more focused on work, netting a 2.5x4=10x total when you remove all the procrastination and general fumbling around of the average developer.


> worth noting I think that RollerCoaster Tycoon was based on his earlier Transport Tycoon engine,

The 10x productivity comes in large part from the code they DON'T write.


And from writing things the right way the first time around rather than on iteration #3 or so.


Environment and control (true ownership) can easily turn 1x into 10x, I'd say. Not saying I could churn out Rollercoaster Tycoon but I bet I'd look, by every metric both reasonable and unreasonable, a hell of a lot more productive working on a game solo with 100% control of all decisions and not having to fret about having something to report in standup every day versus... normal work.


There’s an easy way to find out if that’s true, and it’s to making a similarly successful solo project by yourself!


Productively building and finding the right thing to build to be successful are different things, and one can be good at either while being terrible at the other.


Please dont say that, it's very, very easy to produce beautiful code that will never make any money!


That 4x more focused means "it ain't me, coz right now I'm commenting on HN" ...


Exactly!


The praise given to him for Rollercoaster Tycoon could easily also be given to him for Transport Tycoon, which was also a great game. The community really took it to amazing heights with OpenTTD, but the original was great.


> so at least he did get to split the work up between two projects.

That makes him twice as productive, not half.


Or he's using better tools and languages. (ie, smalltalk vs javascript)


One of the premises of this thread was him writing the game in x86 assembly.


I'd say there are 1000x programmers. Easy. [0]

If we change the question to are there 10x programmers within a team in some "average" company with CVs indicating roughly comparable experience, then ...

The answer is still yes, there are 10x programmers. I've witnessed it myself many times. Not so much because the highs are very high, but the lows are very low.

[0] Fabrice Bellard. John Carmack. Linus Torvalds.


And it's about just loving the work so much more than anything else that when you're in the zone you think about it 16 hours a day and dream about it the other 8 hours! ;-)

Someone who's 2x smart and 2x experienced, only needs to spend 2.5x the amount of time to be a 10x programmer, and that's the realistic difference between someone who is just doing a job and someone who is following their passion.


You are right, they do exist... but they are probably not producing what you expect. I have had the privileged of coming into companies that had a programmer who wrote 10x more code than everyone else at the organization. Unfortunately, the vast majority of this code was not maintainable, riddled with bugs and had several critical security vulnerabilities in it. Good programmers are not programmers that create 1000s of lines of code an hour with no thought to maintainability. If that were the case, we would have 500 million programmers in India cranking out the worlds best code. Any time I hear an organization talk about a 10x/Rockstar/1% developer, I run the other way as fast as possible.


It appears to me that there's a catch. I think those 10x developers can't be 10x out of their domain(s). You never know as well how does each individual prepare for any particular job, how much self-education effort they are amortizing.


Surely it depends a lot on the project. When I wrote the system myself then I was a 10x developer. Now I am working on someone else's code i am not.


> When I wrote the system myself then I was a 10x developer.

Where you 10x more productive than other developers writing systems themselves?


No that's the point. I currently work on a system that is written by someone else. He fixes bugs a lot quicker than me, as he has a lot clearer mental model. I need to reverse engineer ideas from code a lot of the time.


And there’s a 1000x programmer who doesn’t deliver something that a team of 1000 people would create, they deliver something that a 1000 person team couldn’t create in their wildest dreams. Dennis Ritchie, Jeff Dean, etc.


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.


I'm sure Norvig is very good, but I think the sudoku webpage is presenting a finished program in an idealised way, not recording the process he used to write it, false starts and all.

(It seems likely to me that there were some false starts, because eliminate() returns either `values` or False, when both of its callers would be just as happy if it returned True or False.)


Not saying there weren't false starts, but your example of eliminate() is actually a fairly common idiom[0] where, when a function is testing things for "truthiness" or "falsiness", it will return the truthy or falsey value rather than actual True or False. It lets code be more brief because you can do e.g. a check for null and perform assignment of either the value or a default in a single statement, so for example something like this:

  if( maybeNullValue ) {
    myValue = maybeNullValue;
  } else {
    myValue = defaultValue;
  }
can instead be expressed as this:

  myValue = maybeNullValue || defaultValue;
I'm personally a little bit torn about it. On the one hand, now that I'm familiar with it I love how much more concise code can be. On the other, it can have a fairly negative impact on code maintainability: if someone comes along who isn't familiar with that idiom, they might have a bad time trying to figure out what's going on (or worse, they might take offense that all these predicates aren't returning True or False values and rewrite the whole mess--or you could end up with a mix of the two, where some functions follow the idiomatic convention and others return actual boolean values which is arguably the worst)

Also I'm not trying to say that there's not some YAGNI going on here--just that I suspect he did it that way somewhat reflexively, and that in that particular case we probably cannot infer he had originally intended to do something else with those results and then changed his mind later.

[0] at least in the Lisp world, which Norvig has extensive experience with[1]

[1] https://github.com/norvig/paip-lisp


He didn't give an implementation time for the sudoku solver, but he did say he completed the spell checker in a single transcontinental flight.


I don't remember how long it took me to do the spell checker challenge:

https://github.com/dlang/dmd/blob/master/src/dmd/root/spelle...

but I'm sure it was much longer than it took Peter. This checker is used by the D compiler to look for a misspelled identifier when a symbol lookup fails. The identifiers in scope form the dictionary.

It works surprisingly well. I added it to the Digital Mars C++ compiler as well.

https://github.com/DigitalMars/Compiler/blob/master/dm/src/d...


> returns either `values` or False, when both of its callers would be just as happy if it returned True or False.)

That's pythonic.

You don't convert from a data type to Boolean.


I know I'm late to the party, but why isn't everyone mentioning Ron Jeffries infamous TDD Sudoku as a comparison?

A lot of the links are dead these days, I'm afraid, but back in 2007 this was the kind of thing that everyone on HN knew about!

http://ravimohan.blogspot.com/2007/04/learning-from-sudoku-s...


I'm sure Norvig is exceptional in many ways, quite possibly 10x, but the tricky thing about examples is that some things that look hard from the outside aren't. They're just about familiarity.

I saw that you mentioned a spell-checker, and thought "I'd use levenshtein distance. That wouldn't be hard to implement on a flight. I wonder what he did that's better." Turns out, he used levenshtein distance, and tuned the results with frequency estimates. I don't know if I'd have thought of that, but it's also not a mysterious technique--I'm confident a lot of people who work more in related areas than I do would think of it.


“Four thousand dollars!” gasped the CEO. “All you did was walk over and push a little button on the side of that machine. Can you give us a breakdown?” The consultant jotted on a piece of paper and handed it to the CEO.

“Pushing button: $1 Knowing which button to push: $3999″


"...but the tricky thing about examples is that some things that look hard from the outside aren't. They're just about familiarity."

And that's how you become a 10x developer.


While I agree with your general point, the business world typically doesn't have much use for solo 'toy problems' and cares more about working in large teams and all that it entails.

I got into programming because I love the toy problems, but it means that once I have something 90% solved in my head it becomes a huge struggle to continue. Sometimes in my working life I'd have to whip something up to fix an issue or provide a POC which gets thrown away or given to a team (I don't care either way) and those were the best projects.


Norvig's work in those questions are more like the 100x developer category.


If you want an answer to that question: https://news.ycombinator.com/item?id=3033446


Norvig is so another level maybe because of being so literate. I came across a Kakuro (Soduku * crossword) puzzle in a newsprint puzzle booklet, and failing to solve it with a pencil, attempted it in JavaScript.

I am now >10x at solving Kakuro puzzles with access to a command line and the repo (~100ms/10x10).


Solving a sudoku is just an exact cover problem, for which there already exist solvers. Just write a simple transformation program and you are done. https://www.iwriteiam.nl/D1009.html#9


I’ve gotten solving a sudoku puzzle as an interview question, to be implemented in full in 45 mins.


Same (not as an interview, as coding challenge), using simple backtracking and a high level language it's really easy. My solution wasn't anywhere near as good as Norvig's, though. (And today I would just use z3)


Solving suduko is a college homework assignment. Norvig's solution is simple and quick, but he spent decades dedicating his entire professional life to studying all manner of AI, so it's not clear his overall problem solving speed is.hifh including the time spent on past study. In the meantime he wasn't learning to be good at kernel hacking or UI development.


> 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.


Yes, it's this simple. The important point is that some things are just beyond the ability of average programmers, let alone, bad programmers.

There are some things that only top programmers are able to actually finish before the end of the universe.


Oh no, these other programmers get the task done but they use 10x the amount of code to do it and nobody can figure it out. It mostly works too, except on Tuesday's when it's raining.


> these other programmers get the task done

And it only works on the test cases :-)


Apparently they edit tests.


Joel Spolsky's "Hitting the high notes" always comes to mind for me when this debate arises.



Spolsky is a 10x blogger. Neither he nor any of his employees were ever 10x programmers. There was nothing algorithmically clever about FogBugz or CityDesk or whatever.


Did you miss how they cross-compiled Vbscript to PHP? I'd say for a lot of programmers this would have been quite the challenge, algorithmically speaking. And I would classify it as clever. With both the positive and negative connotations of the word.


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.


Being a consultant for a considerable part of my career, whilst sometimes working solo on writing a system from scratch.

In one example, re-writing a system written by 7 team members + architect, taking half the time.. Maybe due to working in an organization without a formal org position.. I had to make sure bad requirements, process, tech decisions etc.. don't get in the way of properly collecting requirements, designing and building this system, seen today as a hugely successful project for this company. I have to say, some people see me as an asshole, no doubt, other's see me as a bulldozer that got the work done and stand behind me and keep in touch to this day.

Our interaction will depend heavily on if you are in my way or not, though I don't consider my self toxic or hoarder of information.


I'm glad this appears to give you some satisfaction, but I hope I never have to work with you, or around you, or on any project you've worked on.


This cuts both ways, smart and competent people might also not like to work with you or any project you've worked on.

I have no real insight into your personality and ability (but neither do you about GF).

Competent people who want or need to fix some dysfunctional monstrosity committed by a coherent group of less able developers are not necessarily welcome, even if they don't have pathological personality traits. All the more if they are not parachuted in to fix something, but e.g. some new starter not high up in the hierarchy. Consider that few people take kindly to being told (if only by implication) that what they've done is garbage, but obviously the world is full of garbage software.

I've seen this time and time again. Long-term diplomacy can sometimes work (assuming the company and individual have the time to spare), but they'll usually need some higher up backing or fail miserably/leave/get-fired.


I've been brought into several moribund projects similar to what @leroman is describing. Usually you are there to push past the bullshit. Often the problems start with someone similar to what you described in your original post.


What is wrong with ignoring and working around toxic people who only undermines the project?


Ignoring sounds passive but there is nothing passive about telling people their ideas and cooperation is unproductive (be it people from product, RnD, management, QA etc), you spend much time and energy convincing them their ideas are not concrete, or are going in a bad direction, or are simply bad.. Having the burden of completing the project (successfully!) on me, I have to cut through the BS and provide results, not attend to egos and fragility of everyone involved.. Never the less, I try to be dry and not personal as I can to communicate the situation as simple as possible to the other party.. In my consulting career I learned that being "nice" is not worth it and ends up costing me in mental health..


"re-writing a system written by 7 team members + architect, taking half the time"

Sure, but are you saying this is about individual productivity or had you considered it might be the costs of coordination?


I wasn't meaning to say anything about the "why", just the facts.. For starters, the project I was working on was a success, the other failed.. so its not even comparing the same thing.

Just offering my anecdotal story as a potential "asshole" offender per OP


Disagree with this. There are absolutely 10x and even 50x engineers out there. Yes they almost always have egos and people complain about them all the time.

But they also build the right product at the right time for the right user and do the work of an entire product + engineering team - often much faster.

Most large, successful companies today have a handful of these guys among the first 20 employees.


This is part of the problem, we (mostly) all agree there actually are 10x and 50x engineers, but there are some people that are conflating 10x execution is being 10x the dickhead. Look in this thread, there are plenty of examples of 10x developers who aren't total dicks to the people around them and don't negatively effect everyone else.

What we need to do is look at the intersections: There are people who are 10x engineers (Peter Norvig) -great. There are 10x engineers who are dicks to the people around them (Linus Torvalds). There are people who think they're 10x engineers but aren't, which are fine (let's be kind as use me as an example) and there are people who think they're 10x engineers who aren't - but are dickheads because of it.

Even if you are a 10x engineer, you shouldn't be a dick - because it's demonstrable that you don't have to be a dick to be a 10x engineer.

I would say it's pretty obvious that the group of people who think they're a 10x engineer and act like a dick is way bigger than the number of actual 10x engineers. That's what I see in the programming community general - everyone has the story of some guy who thinks he's a rockstar but is actually just making everyone's lives hell.

Now if you don't actually know if someone is a 10x-er you've got a group of possible 10x-ers and its polluted by this large pool of people who really are dicks, and really aren't a 10xer


This explains what I was trying to say better than I did :)


I've been a 10X in the past. I don't exactly know why it faded away. Might be that I really REALLY believed in the mission back then but haven't found the spark for anything since. I'm not sure I exuded the toxicity you associate with 10X but I know I wasn't pleasant. I put myself under way too much pressure to get results.

My boss is a 10X all the time. I guess he believes in the mission he's on renovating the IT infrastructure of our org. He's super nice. The antithesis of what you speak of.

Point is: Personalities are different and not necessarily correlated with the 10X trait (if there is such a thing). It might be a host of different circumstances.


Totally agree. My productivity has varied over the decades, as has my attitude to the rest of the team. Luckily, I don't think I ever claimed to be "10x" (lucky because I have been at least that arrogant in the past).


I think assholery and competence are orthogonal qualities. But normal competent people don't need to tell everyone how smart they are, so you won't usually notice them as much.


It's also that people who need to tell you how smart they are, usually aren't ;)


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.


> 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.

I think that's perfectly justified. So much is lost in software quality because those people think programming as dry labour and outsource to cheap sources, losing so much in future revenues but unfortunately that's not even measurable.

Joel Spolsky put it nicely in a post: It is not that it requires `n` bad programmers to do what one good programmer does. It is that `n` bad programmers can't build what a good programmer builds, no matter how big `n` is or how much time it takes.


If you know which algorithm to use or how to find one, then you can accomplish things with even greater multipliers. But empirically, people with many years of experience that have seen everything aren't valued so maybe it just isn't that valuable.

Maybe coordination problems just drown out individual productivity most of the time. Or, looking at it another way, if someone senior (as an IC) hasn't found their way into a position where they have leverage ("impact") already, then they don't have the only (meta-) skill that matters.

But then again, when you won't pay people enough to retain them and "Leslie" happens to be the most productive and abhor interviewing, then maybe you end up with literally one person replacing ten.


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.


> It comes from terrible "corporate drone" software developers in the 80s and 90s - the ones that would takes weeks to developer simple routines.

Ironically, a lot of the 0.1X engineers I've worked with in the 2010s were the most technically competent. Obsession with cutting-edge tools and being technically correct over shipping quickly can sink a person's productivity.

They're the people leading the charge to rewrite the front-end in Vue after we already rewrote it in React when Angular fell out of style. Or rewriting the backend in Rust because Golang isn't trendy any more. Or refactoring the backend for months to increase test coverage from 93% to 95%.

My personal indicator of a 10X programmer is someone who knows when and how to trade off technical debt against speed of execution. A brilliant engineer with all of the knowledge in the world can still sink a team by working on the wrong things all the time.


>A brilliant engineer with all of the knowledge in the world can still sink a team by working on the wrong things all the time.

From HN comments, I get the impression that this is a common problem at companies like Uber. Lots of smart engineers with great technical talent, but they spend all their time making pet apps and services which satiate their interest in and excitement towards programming/engineering, but which have not much direct relation to the actual product or any other ultimate business objectives. If there is any relation, it's indirection upon indirection. I imagine this is probably because the core product is so narrowly-focused and basically "done" that they have to look for any other way to spend their time and energy without getting bored and demotivated.

I would guess this happens at a lot of companies with single, simple (from the user's perspective), narrowly-focused products, like Twitter.


I once worked with a -2X engineer, whose code was so bad that it took twice as long for a 1X engineer to undo the damage he wrought.


"trade off technical debt against speed of execution"

eh? The most important thing I think I've learned is how to trade speed of completion and flexibility and comprehensibility versus putting too much effort into avoiding technical debt and speedy execution.


I think that's often overlooked, good judgement does matter, and probably comes with experience.


The other factor is a lack of personal life boundaries.

The 10x engineers that I’ve interacted with can be found working on nights and weekends because they enjoy it and have nothing better to do.

Working those nights and weekends without coworker interruption also means that they get to learn more things freely rather than being interrupted.

As a result they tend to be highly productive, but I’d argue that it could be seen as unfair to the rest of the employees who want to live a balanced life.


I don't think that is unfair. It’s perfectly acceptable to be a 3x developer.

What bothers me is the people that are happy to be a <1 developer. Or even a <0 developer, whose benefit to the team is net negative.


>What bothers me is the people that are happy to be a <1 developer.

We can't all be above average. So we are either all 1 developper, or some of us are bound to be less.


But we can all aspire to be a >1 developer, even if we're not one currently. I don't necessarily think that contentment with being below average is universally bad (maybe it's perfectly rational given one's preferences for leisure vs. work, for example), but I'd hope that most <1 developers are juniors who hope to improve over time.


Fair enough, but given the current ecosystem <1 still means something.

If it ever gets to the point where everyone is floating somewhere between 0.9 and 1.1, I’ll revise my statement.


It's unfair if they're normal employees, but fine if they're contractors/have their own company.

When they're spending all their working hours on one topic they're taking a huge personal sacrifice which is invisible to their employer while at the same time raising the expectations towards their colleagues. If there's for example two such maniacs in a team, the rest can say goodbye to promotions and raises even if they're actually just as good but don't sacrifice their life at the altar of programming.


These engineers end up with much more experience in a shorter time span. The guy that worked 40 hours for the last 5 years is going to have far less experience than the guy who worked 60 hours for the last 5. More experience tends to lead to better decision making and better code.

That said I'm the 40 hour guy. I want to work to live not live to work. That will make me less of a developer than others but I think I still bring value to my work place. I don't want to look back on a life lived in a cubicle.


I'm not sure about that, there are diminishing returns on extra hours. If you work long enough hours then it will start to have a detrimental effect.


Glad to hear that you don't buy into the myth that longer hours are better for their own sake - I agree.

Realistically, I've never met any programmer who has more than 4 to 6 (on a really good day) hours of solidly useful work in them per day.

Time spent above that, and those 20+ hours above 40, are invariably spent spinning wheels and making mistakes from fatigue, etc. and I think ought to be discouraged in sensibly run orgs.


Making mistakes from fatigue is the tip of the iceberg. As designers and implementers of software, we don't just have to redo the few minutes of work that making the mistake took. The consequences can be much worse:

* Missing key insights which would shave a large percentage of work off of the project.

* Making mistakes in architectural decisions, which require hours of extra mundane boilerplate work.

* Introducing difficult-to-reproduce bugs which require hours, days or weeks debugging

* Destroying key hardware which needs to be re-acquired (if that's the kind of thing you work on).

At this point in my career I'm of the opinion that asking teams to pull late nights and weekends is actually detrimental to project timelines, over anything longer than a single day. All it does is reassure PHBs that maximum effort is being made.


I guess the "nights" part is an exaggeration. Anyone working days + nights will either burn out soon or they're on drugs and will crash and burn later.


Agreed.

I've never encountered someone that I think is genuinely a 10x programmer. I've worked with a few people that thought I was one, which I'm most certainly not, and I've explained that to them.

I've encountered a lot of what I would call .2x programmers though. As you've said, there are a lot of people that are really bad at the job. It's not a slight either - there are a lot of people doing this job that really don't care for it at all.

It's hard to be good at a job you don't enjoy. Especially if life forces you to do it 40+ hours per week.


If youve encountered a lot of 0.2x, then the 2x developer is the 10x developer you are looking for!


> .2x programmers

Why stop there, throw a negative coefficient on it. Some bad programmers actively cost other people's productivity and drain profit when their poor decisions or implementations need to be fixed (or they constantly ask the same questions and never seem to grow past that stage).


> I've never encountered someone that I think is genuinely a 10x programmer.

I have. (Interestingly, some of these people knew this and had a surprising lack of modesty about it as well…) Usually I think it boils down to being able to have the experience to consistently guess right on things, come up with new ideas, and not get tangled in the weeds: most of them are smart, but not so smart that you’re just lost when talking to them.


>> not so smart that you’re just lost when talking to them

That, BTW, is a sure sign that someone is trying to appear smarter than they really are. Having worked at 2 research labs over the course of my career I know more than my fair share of genius-level people. Without fail, they are humble about it, and can explain complex concepts in a way the rest of us can understand. This is something that just blows my mind pretty consistently actually, and IMO it is a sign of true, deep understanding of a complex subject. The person didn't just memorize formulas (although many of them excel at that as well), they understand why things are the way they are, the real meaning behind it all.

It could be that this is selection bias though, and I only got to know geniuses who aren't also assholes.


> a sure sign that someone is trying to

Nope. Explaining things well is a skill. One can be non-excellent at it. Its possible to have a moderately-good grasp of something that you can use while working with it, but not yet have come up with good ways to make your knowledge explicit in a well-organized fashion.


Moderately-good is not genius.

Part of being great at something includes an ability to abstract out common difficulties, which helps other people to understand (even when you are not that great at explaining).

I'm not aware that I've ever met a genius who was working on completely different principles to other people - everyone reaches the same difficulties and has to find a way to resolve those.


> Moderately-good is not genius.

Agreed.

But moderately-good is also not "a sure sign that someone is trying to appear smarter than they are".

> everyone reaches the same difficulties

That is definitely false. I've had difficulties with social skills, the writing process, and knowing how to direct my attention. Some of these are so alien to other people that when I ask questions, it is not uncommon to get responses like:

* Just do the obvious thing.

* This isn't hard.

* What do you think {repetition of my question}?

* You're overthinking things.

* What the fuck is wrong with you?

The folks I've heard get discouraged from maths or science tell similar stories. Part of being good at the skill of explanation is asking questions which help you understand the other person's perspective and what their difficulties are.


>> everyone reaches the same difficulties

> That is definitely false.

A bit strong, and I don't think your examples are necessarily contradicting this. Obviously everyone has their own experience.

Responses such as "You're overthinking things" most often mean: 'I overcame this problem with practice but it happened subconsciously, so I'm not able to express how I did this.'


No, not always. I have talked to a lot of people who are doing something I just fundamentally know nothing about, and I just cannot follow them. In my experience, people who are trying to appear smart are often intentionally unhelpful when you ask them for clarification or details (though there are of course smart people who just choose to be this way…)


As Feynman said: you don’t really understand a subject until you can explain it to your grandfather.


Just a note, Feynman was very bad at explaining things to uneducated people. He was famous for his insights and ability to explain things to other professionals, but his lectures were very badly received by the students. So I'd take that statement with a grain of salt, as Feynman obviously have way better understanding than an average lecturer.


And that's how I explained the cloud to my grandma: the company buys big daddy servers which make baby computers that the company sells for profit. She was so happy she finally understood what my job was at the time.


When I read this gestation/birth analogy, it makes it seem to me like a large piece of hardware assembles and ejects a small piece of hardware. I assume in-person there was more detail or different imagery?


How about: instead of keeping photos in a shoebox in your cupboard at home, you can keep them in a container at a company's storage place. But people want their own box, so the company divide their container box up into pigeon-holes and fit all the shoeboxes in to the spaces in it. If you want to look at the pictures you can go and view them, you only have access to your own shoebox though.

Shoebox is logical computer, cupboard is computer, container is a distant "big" computer (server), pigeon hole is a virtual server.

Now you might have a few boxes of photos at different companies -- the cloud is being able to see/use all those photos at the same time from anywhere in the World.

[Perhaps too close to storage model vs processing model of cloud?]


I myself have noticed that some people just have natural cognitive abilities that far surpass any regular person's abilities, and I guess that's generally a prerequisite for making any new ground-breaking discoveries or libraries. But still, one person can only know/do as much as one person can, and while having very great skills in some narrow domain, other people (or here programmers) might be better versed in other skills than this "10x" person. Thus the 10x depends very much on the task.

What I have come to appreciate more over the years is the ability to communicate and make understandable code that other people can build upon. I think it's our greatest strength to lean on the collective ability of the group instead of depending on some person's individual skill.

And in the end the "10x" is merely a subjective measure, that very much depends upon the people you are comparing to. With a team of 10x programmers wouldn't everyone be then only 1x?


I've certainly worked with them - someone who wrote an entire h265 decoder test suite in three months, for example. My own experience had included times of being the 10x debugger, especially when called into situations that have already consumed a large amount of colleagues time.


The only guy I would describe as a "10x" wasn't exceptionally technical or a genius - I saw him as above average, but I've worked with guys that I thought were more exceptional in those regards.

But this guy had the ability to focus on the most mundane things with unbelievable attention and focus - I would probably need to take amphetamines or something to come close to this level. Combined with the experience he had with this project he was by far the most productive person on the team (and the team had competent developers on it).

And it was not a case of a mad genius locking people in to his asylum project - this project was screwed over by that type of developer years before he joined the team.


> It comes from terrible "corporate drone" software developers in the 80s and 90s - the ones that would takes weeks to developer simple routines

They still very much exist. My previous job was at a bank and these people filled it.


Can confirm. Last week a PM was gushing to me it "only" took a week to implement a feature that was not much more than an extra if statement. This is not in a regulated industry either, just run of the mill web stuff.


I do tech at a non-tech company. Colleague has been doing Python for about 6 months. He can't do for-loops. His brain just doesn't get the concept (among others), I've never seen anything like it. Other guys make general computing mistakes like trying to type into a command prompt while another window is in focus, then messaging me saying "there was an error."


This is not at all comparable to that insane example you just gave, but a lot of people are just tool users in non tech companies. I know because I've seen it in finance. They're absolutely brilliant in their statistical concepts, but their programming skills leave a lot to be desired for because they don't have the background.

For instance, when you move from C++ to Python, you kinda realise after a month or so that normal loops won't cut it for stuff like numpy arrays etc due to the huge overhead. I realised this personally because I knew how quick C++ was and I wondered why the same code in Python was so massively slow, and I read up online to understand it. Similarly in matlab, for loops are very fast but still inefficient. So now when I write code, I use inbuilt libraries as much as possible and in matlab, I make everything into a matrix operation so it is blazingly fast once I scale it to a million data points.

My colleagues have no idea what that shit is. They'll know every step of a complicated algorithm and implement it simply using loops.


> There was an error

When I get these kinds of messages I just want to strangle the person on the other end.

Cool, an error. What did you do to try and fix it? Or was your first step to contact me?! (hint: it is)


It's pretty obvious that there are coders who can do the work of - all of the work of, and better than - a team of 50 talented programmers.

For example when Linus wrote git he singlehandedly outprogrammed every team of version control vendors. He was a 50x programmer. (If not more.)

This is a real literal example without exaggeration.


It really isn't that surprising either. People want to write off the notion that some people are massively better than others at solving problems, but it's completely obvious that's the case. Of course there are insane outliers like Claude Shannon or John von Neumann, but those were real people that existed, and it stands to reason there are people at smaller multipliers who are still much better than average.


That's not an example of a 50x programmer, though. That's coming up with a truly great idea. If there is a new device that needs a driver for Linux, I can guarantee that Linus can't implement it 50x faster than a talented Linux driver developer. I think even Linus himself would agree. He's not a magical creature capable of 50x faster software development, over, say, Junio Hamano. As Linus himself said, "Junio really should get pretty much all the credit for Git—I started it, and I’ll take credit for the design, but as a project, Junio is the person who has maintained it and made it be such a pleasant tool to use.”

This is precisely where the 10x Myth comes from. Linus is not 10x a talented developer, productivity-wise. He is 1000x the value of some talented developers, because he figures out great things to make. But the "10x developer" is about productivity.


I think at this point we are debating the semantics of '10x programmer'. I would say that coming up with good designs and using proper algorithms is what makes people 10x.

I suppose I am saying that if Linus/Junio/whoever can make git in 6 months whereas a regular dev would take 5 years, then he is a 10x--it doesn't matter why he is 10x faster.


I think a good portion of the story there was thorough knowledge of prior art, the ability to identify what was essential and what was incidental and the fact that he built on a singular vision.


Sure, but none of those things were monopolized by Linus. Other teams/engineers could have done the same, tried to do the same.


How do you know they didn’t do the same or better? Linus has the advantage of a huge audience (of adoring fans, no less), there were competing dvcs’s at the time - mercurial, bazaar, darcs - and likely many more in companies and lone developer machines which weren’t successful.

If Linus had released Git quietly, but put his name behind mercurial and used it for the Linux kernel, would Git still be the de-facto standard today? Or is his popularity and influence at least as big a factor as his design or code skills?


Regardless of the success of git, it's novel branching tech was what set it apart. And he did beat entire teams of coders to that solution. Of course his name was what lent it so much credence, but a good solution tends to make waves in online communities. Best example? Bitcoin.


> Best example? Bitcoin.

Yeah but people here don't like to hear that :-)


Yes -- but you shouldn't state the truth because it makes every non-top programmer feel bad :-)

I have another similar funny example - whoever invented bitcoin, that person single handledly created more value than all the YC startups put together PLUS a lot of other incubators, plus a lot of other companies. I wouldn't be surprised if in less than 10 years, you could add to that the total capitalization of the FANG (as in F+A+N+G) and still that one person will have had created more value -- alone.

It takes some special persons, who have not just the wits, but A) know extremely well one or more domains that are generally not connected - say software, finance and game theory for Bitcoin, or software development, project coordination of thousands of persons and hundreds of companies, and scale/complexity issues for Linus B) has already played with the existing solutions quite a bit and know why they suck C) has the opportunity (free time, etc) to scratch this own itch.

I know, people will often tell how it's wrong, how both project are special exception, but then what about Fabrice Bellard? What about the many others? Are they all special exceptions?

TLDR: I believe Kx programmers have a statistic distribution with a very long tail. There are some K=10, some K=50, some with a K even larger. It requires multiple skills + motive + opportunity. Any missing factor and the magic doesn't happen.

Deny the existence of the 10x programmers if it makes you feel better about yourself. Use their existence as a source of inspiration if you want to improve yourself.


Ouch the Bitcoin example is terrible and really detracts from your argument. Currently Bitcoin is sucking value away from real economic output in the form of energy (electricity), financial speculation, money laundering, and cybercrime.


Terrible? I'm sure free software was also considered terrible 15 years ago at Microsoft! In fact, more than terrible- it was perceived as a cancer!

Linux was sucking value away from real research in the form of copyleft (lost IP rights), financial speculation (VA Linux IPO, etc), hacking and other forms of cybercrime (don't they show nmap in the Matrix?)

But perceptions change.

The only thing that doesn't change much is the value created, as measured on the public markets.

Whether you like or dislike the morality Bitcoin (and there is more dislike on HN as usual), the market seems to indicate its potential is greater than an isolated dislike.

You are free to be like the Microsoft of the last millenium and consider Bitcoin as a terrible cancer. But I think your perception will change with time.


There is a market for drugs, child porn, assassination too. Or for email spam, hacked accounts, stolen credit cards, money laundering.

If your conception of value to society is as simple as "people pay money for it", maybe you should reconsider what value means outside of a purely monetary lens.

So far, bitcoin is a much costlier way to transact compared to standard methods - both to the end user, and in terms of energy/resource costs of miners vs. a VISA server.

It probably has some value in a scenario where the government is an adversary. But the government can regulate and track Bitcoin just as well as dollars if they wish to, like they already do in the US by requiring BTC exchanges to collect users identity proofs.

The arguments about how bitcoin is the next big thing and we'll all look silly for laughing at it now are basically empty. I'm sure i will feel silly if it takes off somehow, but that tells me nothing about if/why it will take off. I'll look silly for laughing at ghosts or leprechauns if they turn out to be real too, so what?


To add:

The most effective developers I see are those who ask the right questions. They may have lesser skills than other developers, they may be younger, less experienced, not as smart, etc. However they always produce more. Not because they can type faster, or algo better, but because they know how to leverage every aspect of their team from knowledge sharing, to knowing when to ask about refining requirements, etc.

They think about the whole problem, not just the slice given to them.

Of course there is always a spot for people who are smart enough to algo the shit out of anything, just not as team leads.


I'm easily 10x a good programmer, probably more.

It's all I do, it's all I'll ever do. I'm not a balanced person and I'm ok with that.


Yeah I can commiserate. Aside from going out here and there, social outings, I’m pretty much always programming or reading about programming. I have zero other hobbies and don’t want any.


> It comes from terrible "corporate drone" software developers in the 80s and 90s

These definitely still exist.


Yeah, I can understand the "10x programmer" back when fizzbuzz was still being asked of CS graduates. Not anymore.


To be honest, I didn't know that one... I just did basic double division the first time I saw it (into a float and compared it against an int casted back to a float). Someone in the interview room asked my if I remembered modulo and I was like 'oh yea, it gives you the remainder'


That's honestly more impressive for creativity sake!

FizzBuzz is just an example of the general problem of "given a set of things, do something to a subset of those things" which comes up often in real world settings. If you knew enough to set up a loop and apply some conditional inside of it, then you passed better than some of the programmers I've worked with.


That operator's one I've used more on puzzles than in real life, where I've used it few enough times in 15ish years that I could count them on one hand. I think it only sticks in my mind because, for whatever reason, it was taught early and with some emphasis in a Perl book I read when I was starting out. If not for that I could well fail to come up with a reasonably "correct" solution to FizzBuzz.


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


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.


It seems like you're almost debating yourself here, making arguments for opposite sides. If anyone could do it and environmental effects make all the difference, why emphasize individual initiative?

But maybe the best thing to do would be to find a better environment, if you can?


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.


Ah, so the secret to having a bunch of 5x engineers is to not burn them out.


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.


10x is also about quality. Not raw output. A lot of times the really fast devs are fast because they don't stop to consider how they can do things in a fundamentally much better way, they just churn out the status quo as fast as possible. Those type are not 10x.


I do not think 10x means "churns out code" but rather "produces results". And by this metric, by golly, there are a couple 10x out there for sure.


I think OP here was asserting that he was 10x in comparison to that guy, as being much more efficient.


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.


The modern workplace for an employee is really not designed to incentivize above average productivity. I don't claim to be an anything-X developer but I find my productivity runs in cycles. In the circumstances I've turned out high value work in a matter of hours or days, I've literally been told by colleagues to slow down because I was making them look bad, while management assume that's just how long the task takes. At the other end of the spectrum when I'm (relatively) under-performing nobody cares: that's just how long a task takes, and nobody feels threatened.

The damping effect is real.


I recommend going into consulting/contracting. A lot of money to be earned if you are really productive.


> then expend your remaining energy helping your teammates grow, and broadening your influence

All through reading this thread, my thought was that I'd rather be a force multiplier than a 10x programmer. I'd rather make an entire team write better, more maintainable code than just do more of the code myself. Past a certain point, the force multiplier adds more overall, plus their influence results in less _bad_ code, they raise the minimum bar.


There are companies programmers are the ones doing the estimating, project managers hold them accountable, and managers dish out promotions and convey priorities.


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?


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.


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.


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?


I never understood the concept of 10x apart from it being a (misused) meme. For (almost) every developer you can find one that will do "the thing" a few times faster and one that will do it a few times slower. It also depends on what is "the thing".


This is another example of this delusion people have about specificity when comparing outliers to normal people.

Genius level programmers are better than you at everything related to computer science. And if they aren't familiar with it, they will become familiar with it in a fraction of the time and then easily surpass you. This is why we call human intelligence 'general'. Because it applies everywhere.

Unless you think your ability to do your job is entirely dependent on tooling and learned knowledge, smarter people will quickly become better than you.


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).


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.


Team sports is a terrible analogy. Like someone else mentioned, software is about leverage. There is no leverage in team sports.


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)????


Are we talking about a case where a given developer has re-written 100 lines of code, and added 1 line net?

Or do you mean that only 1 line was written or re-written? If so, what are people doing, having 7-hour meetings?


No. We had 31 million lines of code and it was so complex that even changing 1 line had massive implications. Definitely the worst code base I've ever worked on. I originally started working there as a contractor because they had single functions which had reached the file size limits for their build system and they didn't know what to do (you know... maybe split this function up into smaller functions... maybe...). There were people who were unrolling loops because they were unaware that the compiler would do it for them under the hood. And then somebody would modify one part of that loop, so you'd be looking for some strange behaviour and it would be buried in the middle of some code that was copy and pasted 100 times. Total nightmare. Don't even get me started on how they did their memory allocation.


Very curious to know what you were working on! 31 million lines of code?


It was a telephone switch (Now defunct Bell Norther Research)


The scale of this is too vast to even conceive....


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.


Communication overhead is expensive. All else being equal, it’s much better to build a small elite team that can operate successfully with less structure and process, rather than a large average one.


Right. But you can't build a functioning team that works together and can rely on each other by fostering a culture of competition and hiring only the "predestined" 10x engineers.

If the team culture is to help each other, forgive mistakes and learn from each other without measuring who's the best the team will automatically build itself without the need to hire only "10x engineers".

Or so I suppose. I'm not an HR person or anyone else with expertise in this field so you should take what I say with a grain of salt. I've just been thinking about this a lot as of late.


Where I’ve seen teams with high concentrations of unusually smart people, they gelled and collaborated at least as well as anyone else. In fact the bandwidth and fidelity of their idea transfers is part of what made them impressive. It’s like they had their own little language to describe the codebase and what to do with it.

These were mature and soft-spoken people; might be different with brash young hotshots.


To me that sounds like an environment where there's not a lot of competition involved. (Which is what I was describing.)


They were far and away the most selective team in the company.

I’ve seen this before in university too; competitive to get into can still be cooperative once in.


HN thread limit might cut this off but what if someone in that team starts experiencing problems and self-doubt? If everything in the team has always worked smoothly before they might not be able to handle it.

Additionally, elitist teams might scare off some people that could otherwise be great engineers if they just got a little entry help. Sure they can "get that elsewhere" but if every team behaved like that there's not only nowhere to enter, but there's also sort of an omnipresent assumption that you have to be good from the start in order to be able to achieve something in engineering.

I'm not saying your described team doesn't work but it's not exactly the kind of culture HR should be striving for in my opinion. (Albeit it's still far better than than a team that doesn't work at all or works against each other.)


Your dream team is great, missing only a 10x person to lead them, inventing MapReduce or MacOS or AWS.


True, but if you culled the bottom 30-50% of programmers, how much productivity have you lost?


Probably a lot because now a lot of programmers up to maybe the top 10% or 20% are worried they're not good enough which will lead to a lot of stress and in turn, less productivity.

Aside from that, if all of programming is competitive it will keep a lot potentially very capable people from entering the field because not everyone (regardless of ability) is made for competition.


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.


> 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.


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.


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


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


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


If you think 10x programmers are merely more efficient and writing code, you're wrong. A 10x programmer produces 10x less code to solve the problem which is why they're 10x faster at it and the quality if higher.

Some of this advice is good but actually being speedy is not necessary.


> 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

10 x 20 x 5 x 47 (or however many weeks you work a year) divided by 3600 is about two days of work, or three minutes per day. Hardly an out-of-control cost. Now how many minutes do you spend on HN or other websites that have nothing to do with work?

The (potentially) bigger cost, but harder to quantify, is the effect of those distracting moments on your working memory, flow, and ability to focus on the task at hand. I, for one, would like to make code appear and things come to view on the screen at speed of thought. I think that just would make it easier to focus on the thing you're actually trying to solve, as opposed to the mechanical work of making the parts of the solution materialize in code.


I think the thing is, these things are all irrelevant in the grand development scheme.

What is really going to save you (and your team) time is knowing to have a test for the critical scenario(s).

Or knowing to build something right (and finding out what right means) the first time around.

From my perspective, it's all about trying to save yourself from future work.


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...


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.


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 :)


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.


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


> 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.


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.


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.


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.


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


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


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.


The equivalent comparison would be professional athletes at the top of their sport to other professional athletes in that sport working or playing in a lower league. Would the the top performers be 10x the other ones? Hard to quantify this, but I'd say no, more like 2x or at most 3x


All you have to do is look at someone like LeBron. He single-handedly makes a team a championship contender.


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)


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!


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.


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.


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


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.


Not trying to be a jerk, but I think you might need to re-read the article as the author is clearly a developer themselves and thinks that there are definitely 10x developers (just that they can't be found with a simple coding test).


I would like to think I’m one of them, I’d flail about in attempt to solve some random programmer test, but I’m also the guy that sits back and says ‘hey how about we rethink this i n s a n e architecture?’


Please read the article again. Or even just the title!


I think you missed the double negative in the title.


I'll bet 10x managers do exist, but they quickly become VPs or CEOs


By that reasoning, for all practical purposes, they don't really exist. They were already rare to begin with but then they also move up the ranks quickly.

One could argue VPs and CEOs technically have people reporting to them, but managing people isn't really their job. They are mostly concerned with strategy.


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

It is also a concept which is NOT SCALABLE.


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.


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


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.


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.


10x programmer @ 1x pay


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.


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.


This guy is so 10X his/her user didn't exist before this response. And he's been 10X and productive talking about it!


Linkedin request sent.


Can't tell if this is /s or real.




Applications are open for YC Summer 2021

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: