Millions of keystrokes have been expended on the internet on the subject of the 10x developer. There are a number of different definitions and many questions whether it’s a real phenomenon at all. But the myth is too good for most people to give up. Are there really developers out there who can amplify your results ten times?
The truth is that there are developers out there who are 10x but they are not the ones you think. They aren’t lone wolf rockstars, with a reputation for doing on their own in a few hours what most teams would take a week to do. The truth is even more fascinating and can be the key to multiplying the effectiveness of your team.
What is a 10x programmer or developer?
There are a number of definitions out there for a 10x developer. Here are a few we found.
- A developer who can use the tools and resources available to them to achieve 10 times the performance of the worst developers. Source: Kenny Bergquist
- A developer who can do stuff that a team of 10 lesser developers wouldn’t be able to do. Source: Yevgeniy Brikman
- A developer who is able to unlock 10x productivity in their team. Source: Sylvain Kalache via Stack Overflow
But are any one of the true definition of a 10x software developer? Does that come from some combination of all three of these traits? If you are hiring, your first priority is to amplify your company’s results. Does that come from a hyper-efficient developer or a team builder? To find out which are most important, it is useful to go back to where the idea of the 10x programmer and later developer began.
The origins of the 10x developer
The idea of the 10x software developer first appeared in a study titled “Exploratory Experimental Studies Comparing Online and Offline Programming Performance” from 1968. The authors of the study, Sackman, Erikson, and Grant didn’t actually set out to test if the 10x software developer was real. Instead, they wanted to test the differences in efficiency between online and offline programmers (online means on a computer while offline means on paper), a distinction we no longer care about since pretty much all programming is done online.
But the interesting take away from this study was that there is a great deal of variation in the performance of seemingly identical programmers, suggesting that some could be wildly more efficient than others. Well, some of the differences were less dramatic when accounting for some of the flaws of the study. With these flaws taken into account, supporters like Steve McConnell of Construx Software still contend that the study reveals as much as a 10x difference in the performance of seemingly identical programmers.
Since this study was released, variations of the 10x effect have appeared in other research.
- Barry Boehm and other researchers concluded that developing a program with a team in the 15th percentile of programmers ranked by ability typically requires about 3.5 times as many staff-months as developing a program with a team in the 90th percentile (Boehm et al 2000). Source: Construx
- Joel Spolsky also observes the effect in computer science students at Yale. It is worth reading his explanation of the 10x phenomena in Hitting the High Notes.
In a group of equally experienced computer science students, time spent on a project doesn’t correlate with the quality of code. Source: Joel Spolsky
These are hardly the only studies that have observed a magnification effect with G. Gordon Schulmeyer,
Researchers have found between a low of 5 to 1 to a high of 100 to 1 ratios in programmer performance. This means that programmers at the same level, with similar backgrounds and comparable salaries, might take 1 to 100 weeks to complete the same tasks.
But as Gordon points out, these studies don’t consider the negative effect these developers can have on productivity. One developer can bash out a program in a tenth of the time as another but it might be all spaghetti code. If it takes their colleagues 10 times longer to unravel it, the developer’s contribution is effectively 1x.
If you couple spaghetti code with a developer who hurts the cohesion of the team, they might tip over into making a net negative contribution to a company’s output. With that in mind, you need to ask yourself a big question before you try to add a 10x software developer to your company.
What traits should you look for in a 10x software developer?
1. They know what to do
This should be an obvious first step but a 10x software developer knows how to solve most problems immediately. At the very least, they should know what they need to do and if they don’t, the right questions to ask. Source: Stackify
Whether their abilities come from superior experience or knowledge, they can make the right decisions about how to proceed with a software development task. As Chris Stainthorpe, the technical co-founder of CustomerSure, says:
The ‘10x’ coders I’ve worked with have the gift of making ‘boring’ technology choices, showing empathy towards user needs, and a big-picture view of the software product lifecycle
Source: Stack Overflow
Somebody who isn’t 10x simply can’t fill this role. As Joel Spolsky describes it,
It’s not just a matter of “10 times more productive.” It’s that the “average productive” developer never hits the high notes that make great software.
Source: Joel Spolsky
What you’ll find is that the best programmers have very good experience with pattern matching skills and can also do very complex debugging that a lesser programmer simply wouldn’t be able to do. Source: <antirez>
2. They understand why they should do it
You have to have a passion for the problem and understand it inside and out to truly be a 10x developer.
If you understand the problem inside and out you’ll be able to make the right decisions. After all, a 10x developer isn’t just 10x because they can work quickly, they are 10x because they don’t waste time going down the wrong avenue. They usually have an understanding of the machine they’re working on (the operating system and other components) and have a good theoretical knowledge of the technologies they are dealing with Source: <antirez>
3. They know when they should do each thing
A 10x software developer understands where time and resources should be spent to get the most optimal outcome. A true 10x software developer won’t simply start coding immediately and spit out whatever they come up with. Instead, you’ll find them deciding how to best spend their time. Source: Stackify
Fully understanding the architecture of whatever project they’re working on before they start working can lead to massive time savings. It prevents them from going down the wrong alley, putting in unnecessary work, and generally working on time-consuming projects that have a minimal benefit.
Put another way a 10x software developer will cut a part of the project that might contribute 5% of the overall outcome but result in 80% of the time and effort invested Source: <antirez>
4. They add to the work culture
There’s a big debate around 10x programmers which sullies the idea for many people. The crux of it is that you often get high performers who simply do not work with it the rest of the team. Sometimes called ninja programmers, these people might produce amazing results but will not be able to lift up the team around them. In extreme cases, their arrogance will drive the rest of the team to leave, negating any benefit they gave. Source The News Stack
In fact, Rand Fishkin, CEO of Moz cautions against hiring 10x jerks for this very reason saying that he would suggest hiring an average team builder over their 10x counterparts any day because simply it’s a pleasure to work alongside them. Source: Code Mentor
But if the idea of 10x is that you create 10x the result. If you have a developer who empowers 10 other people to increase their productivity ultimately ending up in 10x productivity for the team, they are a 10x developer. Source: Stack Overflow
Take this anecdote from a contributor pradn on Hacker News. The contributor gives a perfect example of how one person can create tremendous value for the team they are on.
I’m in a team right now which I believe has a 10x software developer. He picked a simple threading model to prevent tons of wasted time on deadlocks and other threading issues. It’s also easier to reason about and get new people on-boarded. When he reviews code, he finds bugs that prevent days of debugging down the road and suggests simpler architectures that make the code easier to understand and change. He has had this effect on ~20 people over ~5 years. I would not be surprised if he saved us ~1 year of dev time collectively.
Source: Hacker News
The contribution that this particular team maker makes doesn’t just elevate him or herself, it elevates the entire team. This person acts as a multiplier for the team and this is the true results that you want when you are hiring. Source: Sean Cassidy
5. A 10x software developer fits the role you need them to perform
Another issue that commonly comes up with the idea of the 10x software developers they can be put into any role and perform at a 10x level no matter what technical environment they happen to be working in. Source: Codementor
It is certainly true that a 10x performer will be able to produce advanced results in most situations, but that belies the fact that some people might be 10x for specific situations and specific technological environments. Elsewhere, they will really only produce normal results. It is important to make sure that a developer will be 10x in your company.
6. They are always trying to improve
A 10x should always be learning new things. Every new skill, tool, and approach is a new way to solve a problem. Not only that but they will stay abreast of technology changes, keeping them producing at a 10x level.
How to test the skills of a 10x software developer
10x software developers who don’t trade on their reputations as rock stars are pretty hard to come by. They require a more screening than a regular candidate.
Check their specialist skills
If you find a developer who you suspect is going to help your team reach 10x productivity and output, the first place to start is with their job skills. Probably the best way to look at this is where the work sample test. The work sample test is uniquely adapted to identify skills which amplify output. This is because unlike an algorithmic test, a work sample test tests business problems rather than simple coding aptitude. And it is really easy to do using DevSkiller.
Say your candidate is most comfortable with Java. Give them an advanced Java test and see how they do.
Check how adaptable they are to new programming environments
But a Java test isn’t enough. A 10x developer should be able to adapt themselves to a certain degree to other technological environments when they need to. So let’s say you’re candidate says that they’re very comfortable with Java but never uses Python. In addition to their Java task, giving them an easy Python task. Even if they had never use Python before, a true 10x developer should be able to figure out how to complete a basic task in the time allotted.
Check their debugging skills
One of the true hallmarks of a 10x developer is their ability to do complex and high-level debugging. This is the kind of debugging that a normal developer could be given an infinite amount of time to complete and still would not be able to do. This because they simply do not have the skills and understanding of the technology.
Once again, you can use an automated platform like DevSkiller to give the candidate advanced code with advanced bugs that they’ll need to find and remove. You’ll find that a developer who can do this will provide a hundred to one productivity advantage over a normal developer. Source: Nevo
Invite your best candidates to a coding interview to see how well they work with others
Part of testing someone’s coding skill is to see if they have the technical knowledge to truly provide a 10x contribution. But the other half of being a 10x developer is being able to elevate the other people on your team so that the team itself makes a 10x contribution. To do this, you need to figure out how well the candidate works with others and how they can improve the team’s output.
Probably the best way to do this is with a pair coding interview. In the interview, an interviewer works with the candidate to solve a business problem. This kind of interview isn’t just about getting a sense of how well they understand coding. It can also show the kinds of decisions they make, how they respond to feedback, and how well they cooperate with others. Even if the developer isn’t available for a face to face interview, it is easy to set up one of these interviews remotely using a platform like DevSkiller.
It’s time to find your 10x developer
Before you go hunting for unicorn 10x developers, it’s important to understand that they are almost as rare as the mythical beasts. You will probably find a lot of average developers and truth be told if you have a 10x developer on the team, they can greatly increase the productivity of the average programmers around them so it’s still worth looking for the one amplifier.
The important thing to remember is to:
- Find a developer who fits your needs (You can start by checking out their open-source contributions). This means one who will be 10x both in the technological and managerial environment of your company.
- Make sure that they are both excellent on their own and excellent with a team. You don’t want somebody who is amazing on their own but then drags down the rest of the company.
- Do extensive tests both to see how good they are in their chosen field, how well they can adapt to new environments, and how well they can work with others.
So now that you’re ready it’s time to go out and find your 10x developer. The rewards will be amazing for you and your company.