Stories about Software


10x Developer, Reconsidered

Unless my memory and a quick search of my blog are both mistaken, I’ve never tackled the controversial concept of a “10x developer.” For those who aren’t aware, this is the idea that some programmers are order(s) of magnitude more productive than others, with the exact figure varying. I believe that studies of varying statistical rigor have been suggestive of this possibility for decades and that Steve McConnell wrote about it in the iconic book, “Code Complete.” But wherever, exactly, it came from, the sound byte that dominates our industry is the “10x Developer” — the outlier developer archetype so productive as to be called a “rock star.” This seems to drive an endless debate cycle in the community as to whether or not it’s a myth that some of us are 10 or more times as awesome as others. You can read some salient points and a whole ton of interesting links from this jumping off stack exchange question.

I’ve never really written about this because it’s hard for me to have a non-nuanced opinion. I mean, I’d be willing to hypothesize that if you scoured the globe, you could find a couple of people for whom this is measurably true. Perhaps Alice and Bob each wrote a phone app in 3 weeks, and Alice grossed $10,000 while Bob only grossed $1,000. Alice is a 10x developer, where x is Bob. Of course, I wrote zero apps while they were each doing that, so Alice is a {undefined} developer as a function of Erik. Actually, no, come to think of it during those weeks I went on an audio book binge and I actually spent $200, so Alice is a -50x developer. Pretty impressive, since her awesome can counteract my bad 50 times over. Alice could support my audio book habit for several years!

Hopefully that weird little exercise has implicitly driven home my point about my hesitation to have an opinion on this, but in case it hasn’t, I’ll state it explicitly. Defining what it means for a developer to be ‘productive’ is an extremely difficult problem all by itself, to say nothing of controlling other variables and attempting to measure differences in productivity. Having read Code Complete myself and, back in grad school, some white papers on this subject, what I recall is that there’s nothing, per se, to indicate that they didn’t find instances where some set of folks were somehow more effective by an order of magnitude. But what’s questionable is how broadly applicable that might be in the general case or as a property of the human beings doing the work rather than the environments and circumstances of those folks. To clarify, if you fed me a six pack and asked me to write some Cobol, I’d probably be orders of magnitude less productive than if you gave me a cup of coffee and asked me to write an MVC application. So, does that mean that I’m both a 10x developer and a 0.1x developer?


Mehdi Khalili once introduced me, through his blog, to the term “Net Negative Producing Programmer,” to describe a person who is actually a drag on the team rather than any kind of help, however middling. That speaks to most of us, I think, anecdotally and intuitively. There are people who are simply so checked out or so toxic that they contribute little if anything while slowing others down. Similarly, there are people who are essentially ballast when it comes to producing software: newbies to the team lacking domain knowledge, initiate programmers, overhead personnel, etc. And that adds in some very real, practical cases that seem to throw the universality of a ratio into question — if a valid scenario is causing me frequently to divide by zero, I might need a different framework to be descriptive than a simple ratio.

I think that our tenuous grasp on even a semblance of an ability to measure this in practical circumstances makes it a footnote piece of trivia at best. “Did you know, that in certain circumstances, developers with one set of circumstances can be 10 or 20 times as efficient as developers with another set of circumstances!” Hardly Earth shattering. Anyone who has ever been sentenced to Rational Clear Case could tell you that. But as soon as it was turned into a meme and used to create self-selected classes of developers (cue recruiter pitches “we’re looking for 10x rockstars that can rock out on our ping pong tables, B players need not apply, brah!”), I think the damage to discourse began to outweigh the usefulness of the information.

But I also think we can take it back. Beyond avoiding beer, Cobol and Clear Case, I’m not entirely sure how I can alter my circumstances to the marching orders “be 10 times more awesome than you are right now!” What I do know is how I can, in a period of time, create 10 times as much value in the world of programming. It’s really pretty simple. I can, during that time, pair up with 10 less experienced developers and show them how to find solutions in minutes for things that would have taken them hours or days. I can make myself available to answer their questions. I can intervene at the point where they’d have thrown up their arms in frustration and despair and spent the rest of the day reading buzz feed and cracked. I can clear obstacles from their paths and help them get things done. I can get them excited about programming and enjoying their jobs.

If I were a high performing developer, but I did none of that, and just used those less experienced or less engaged developers as a prop to make the claim that I’m in some kind of elite club of “10x” people, the opportunity cost of my attitude would more than offset my skill from an industry perspective. If, instead, I help them up their game and overcome hurdles, then perhaps that 10x designation might actually mean something.

  • The most salient point I’ve heard about the 10x developer is from this post (http://www.seancassidy.me/you-are-not-a-10x-developer.html) stating that “greatness” most likely follows a Pareto distribution, not a Gaussian one.

    I agree that greatness is a fuzzy metric. If you’re adding value to your company, community, etc., you’re at least one the better side of the fence in general.

    I look forward to reading the NNPP article.

    • I jumped through that article pretty quickly i think one major flaw in his premise is he brings 10x developer to be computer scientist. It’s not about whether you can solve arcane or incredibly difficult problems, or solve never before solved problems, it’s about whether you can solve the correct problem efficiently for your domain (likely your business).

      The biggest problem in modern software development is solving the wrong problem. It happens nearly every day at almost every job.

      • I’m glad you posted this. It was late and I was battling wordpress, so I forgot to touch on the idea of how much building the wrong thing would skew any measure of applied developer productivity. You could be the greatest programmer on Earth, charging off to solve a problem no one cares about or that you fundamentally misunderstand. That’s another, equally valid, case where the ratio contains a 0.

        • Worse than 0. You now have spent: time, money, and effort to create something that will at best be thrown away. At worst it will live on costing more and more to be maintained and supported.

          Very few people have the courage to admit error and throw away anything, instead they double down.

          • Fair enough — adding in salary and opportunity cost, that is indeed worse than 0.

    • This was the NNPP post in question: http://www.mehdi-khalili.com/dealing-with-net-negative-producing-programmers (I have no plans, per se, to write about that). Thanks for the link, too. Interesting to consider what sort of distribution curve might describe greatness.

  • disqus_hQ7jQy0YKu

    I think you got off track comparing specific instances. For me it is all about “ranking” developers. 1X and 10X are just two levels with arbitrary names. The whole thing comes down to some developers are better than other developer and will always be better.

    For example, at one of my many jobs, I worked with a programmer that was supposed to write a utility that would find the SQL Server SSRS Reporting bin directory and copy some files to it. Since there are many version of SQL Server that we support, he was supposed to build a list of the installed versions for the user to choose from. He did this by hard-coding the paths he found on his machine. He was aware, but did not consider that SQL Server may be installed on drive D instead of C. I worked with him enough to know that I couldn’t teach him how to correctly think about and solve the problem.

    This kind of developer may ship code that looks like it works. Some users will even get it to work and be completely happy with it. Others will find all kinds of issues. We will get a ton of bug reports and have to do major rewrite to get the feature to be acceptable.

    I’m 100% for pair-programming and bringing other developers up to a higher level. The horrible truth is that there are a large number of developers who can not learn more than they have right now. This can be caused by intelligence issues as well as not having interest in learning.

    Whenever I’m using the 10X Developer idea, I’m usually talking about the potential levels not the level right now. A “10X” Java developer is pretty much a “10X” C# developer given a little time.

    • I’ll concede the point that different software developers have different aptitudes for the skills that surround software development (which I’d say are actually fairly diverse). But some questions occur to me:

      (1) Why rank developers? This seems like a vanity metric at best and an organizational anti-pattern at worst. (One might argue that this might be used to determine salary, but I might have a long post or chapter in a book up my sleeve about why I think that’s a suckers’ game for those being ranked)
      (2) If X and 10X are just synonyms for qualitatives like “bad” and “good” in determining a spectrum of developer skill (or even aptitude), isn’t the implication of quantifiable valuations a problem?
      (3) What would you think of using a different set of evaluation criteria on someone whose apathy rose to the level “I’m just not going to learn anything new?” In other words, even if that person is a “good” developer (or a 6 out of 10 or whatever), isn’t that attitude still a potential source of problems in a group?

      • disqus_hQ7jQy0YKu

        I think we are just viewing this from different angles. I wasn’t trying to label people, determine salaries or anything like that. You could have the same issues with Junior/Senior/Architect.

        I don’t like ranking or labeling people. Buts that’s how our brains work to try to simplify the world. The neat thing is that people can change their “ranks” if they want to. Sometimes if you put them in the right environment they flourish. Figuring out how to build the correct environment for each person can really change their lives.

        • That sounds like something I can agree with. What got me started on this post was a vein of thought like, “I think I can have far more impact by helping other people flourish than by trying to become or prove that I’m a ‘rock star'”

  • Mike

    I often wonder if bug creation, code readability and code maintenance are factored in.

    If I work at ‘x’ productivity and a nearby senior or lead engineer works at 10x, does that mean I’m less productive?

    What if I create less bugs?
    What if I code using SOLID and rock star developer loves hammering out mega-methods?
    What if the code I write is easier for new comers to understand?
    What if I create more documentation?

    I’ve needed to maintain some pretty messy code that was written by “10x developers” in the past (as labelled by the team itself).

    The reason I bring it up is that I often feel undervalued on my team or that I’m “slow”. Yet, I’d argue that I’m meticulous and careful about my code. Perhaps it’s my own perception, or simply that very few people speak of how awesome I am. 😛

    Given this example though, it’s clear that the 10x developer is definitely bringing more value. It’s hard to say though how this stacks up over time. Especially if Alice’s application is riddled with bugs and needs lots of support.

    • Thomas Lassanske

      You’ve also got the cases where the “rockstar 10X programmer” commits his stuff, and then everyone else has to react to it, modifying the tools to support the new work, fix the bugs he introduced, clean up the code to meet standards, rewrite the systems that relied on the prior interface, create tests, etc.

  • I’m currently working with a guy who seems like me to be a “10x developer”. Maybe not exactly “10x” but he’s definitely pulling for the team. Part of that is because he seems to work insane hours and takes no time off work – he’s also pretty productive in his normal time too. This guy isn’t your standard Comp Sci student either. He’s straight out of college but just “gets” programming in a way I’m not really sure how.

    Thing is though, although he has many positives and is incredibly fast (committing around 5-6k git commits / year ) there are still weaknesses there I can spot. I think a truly great developer also sits back, thinks and spots issues with the current process and notices improvements that can be made to improve efficiency or reduce future problems.

    It’s absolutely not just about cranking out code. If I didn’t have to context switch so much between projects and also manage email communication etc. and other activities I would also be an order of magnitude faster. I think it helps having people within the team who are essentially code monkeys but you need a good balance of different types of people to make up a great and successful team!

    Great read – enjoyed it.

    • It sounds like you’d be interested in measurements of team efficiency rather than individuals. Is the team’s makeup such that it works efficiently and diversifies its skill set, does the team get along, etc?

      Glad if you enjoyed the post, and thanks for reading!

      • I work for the BBC. Currently work for the team in Sport that delivers the live pages e.g. http://www.bbc.co.uk/electionlive. It’s hard to measure efficiency and how well the team gels. To be honest the biggest indicator is whether we deliver what we promised, within budget and on time (I guess that’s how most tech teams are measured).

        If anyone isn’t pulling their weight it’s pretty obvious to others in the rest of the team but if I’m honest as with any publicly funded large organisation it’s hard to get yourself fired once you’re passed the probationary period. Normally the best thing is just to figure out why they’re underperforming and help them rather than have a negative ‘get rid’ attitude. After all if they were smart enough to get through the interview stages then they can’t be a lost cause.

        • I’ve certainly seen that dynamic in large orgs. In my experience, a lot of low performance of that nature is explained easily in that people are perhaps in the wrong role or on the wrong team. I’ve seen people do pretty poorly as developers because the love of the game left them, but they’ve been productive in other roles.