Getting to 10x (Results): What Any Developer Can Learn from the Best

What if I told you that you can be 10x better than average? Not twice as good. 10 times better: An order of magnitude. You will really stand out. You’ll have access to better jobs, higher pay, and increased job satisfaction.

I’ve interviewed, taught, and mentored hundreds of developers. Perhaps the most valuable takeaway is that there is a huge range of skill levels, even among developers who have been coding for a living for years.

Even more striking to me though is how easily most of them can improve. I’ve also noticed that a large number of developers want to improve. What they seem to struggle with is knowing what to work on and how to work on it.

The good news for those committed to excellence is that most other developers are simply not aware of the opportunity to improve, or not motivated enough to make the commitment.

Simply deciding to become a 10x developer will give you a huge advantage over the competition.

What’s more, 10x isn’t just about development skills. That’s just one factor in a large range of important factors. Obviously you can’t be a 10x developer without the chops, but coding chops alone are not enough.

The Origins of the 10x Developer Meme

A preponderance of research suggests that there is an order of magnitude difference in performance between developers. To quote Steve McConnell (author, “Code Complete”):

The general finding that “There are order-of-magnitude differences among programmers” has been confirmed by many other studies of professional programmers (Curtis 1981, Mills 1983, DeMarco and Lister 1985, Curtis et al. 1986, Card 1987, Boehm and Papaccio 1988, Valett and McGarry 1989, Boehm et al 2000).

It turns out that this 10x thing extends way beyond individual developers. The differences exist in team productivity across a range of industries, skill levels among all kinds of performers and athletes, etc…

10x seems like a whole lot of difference. It’s easy to make the mistake that the rest of us don’t have any chance to reach that level of excellence — the simple fact is, most of us won’t. But what’s really interesting is that there is a clear path to excellence. People aren’t born great developers. They get there through focused, deliberate practice.

It raises an important question: What exactly should we practice? What do the best developers have in common, and are those qualities things that the rest of us can learn from and emulate?

What Makes Some Devs 10x Better Than Others?

There are a lot of factors that make some developers 10x better than others. It’s a lot more than how many tickets they close. Of course getting work done is a vitally important measure, but what else can you improve on to get to 10x, and what should you work on first?

We surveyed about ~1,000 developers to find out. First, we conducted an informal survey on Twitter to collect words used to describe extraordinary developers, and not so extraordinary developers:

Then we consolidated responses into a list of simple, descriptive words, and created a survey with 2 multiple choice questions.

What Makes a Great Developer?

1. Think of the most extraordinary developer you ever worked with. Select all the words that describe them.

The idea here is give developers a list of qualities they can focus on. These are all skills that you can practice and improve on.

Let’s start by looking at what makes great developers great. We’ll start with the top 5:

It turns out that all of those factors beat common productivity measures like “fast” and “efficient” by a healthy margin.

Problem solver: Problem solving is what developers do, so it’s no surprise this quality gets high marks, but what sets apart an average problem solver from a great problem solver? Solving the right problems. Developers want to feel productive, and get frustrated when there are things holding them back.

In most large codebases, there are parts of the code that nobody wants to maintain. If you can make the time to dig into that part of the code and clean it up, you’ll make life easier for everybody who has to deal with that code.

If there are common processes that need automating, make the time to automate them. Score some big wins, and your coworkers and managers will appreciate the initiative. Focus on the problems with the most impact. If every developer on the team spends 5 minutes a day on a repetitive task that could be automated, and it would only take you 30 minutes to automate it, do it. On a team with 6 developers, it’ll only take 1 day to pay off the investment.

Skilled: Skills are developed from two ingredients: understanding and practice. First you have to know what to practice. You have to understand the concepts that form the foundations of the language and craft of programming, and then you need to put that understanding to work.

If you’re not sure what to learn & practice, take a look at the “Top JavaScript Frameworks and Topics to Learn in 2017”. Tech changes quickly, but the language adapts slowly, and learning tools like React & Redux will teach you architectural patterns and programming concepts that will serve you well for years, regardless of the framework of the month.

I sometimes interview developers who answer all of my questions beautifully, but as soon as I ask them to show me examples in code, they stumble. You need book smarts and practiced skill. Having only one or the other won’t get you very far. As you read about new concepts, be sure to practice them, and then try to work them into your every day code. Make sure you have a really solid grasp of when and how to use the concepts, and a thorough understanding of how they work in actual apps.

The best way to learn to code is to code.

Mentor/teacher: Knowing a lot about programming is great, but you’re just one person. No matter how productive you are on your own, there’s no way you can match the performance of a great multiplier. A multiplier is somebody who multiplies the productivity of entire teams.

It’s difficult to over-emphasize the impact that a multiplier can have on your team. Even if the multiplier were to produce no code themselves, on a team of 3, you’ll still come out ahead if one of them is a great multiplier:

• 2 1x devs
• 1 10x dev does nothing but help the other 2 devs reach 5x
• 3 devs can match the value contribution of 10 1x devs

In reality, teams with a strong mentorship culture tend to mentor each other. Everybody contributes some code. One or two stand out and invest more of their time helping other developers and providing higher-quality code reviews.

Of course, simply throwing more throughput at a problem won’t produce better results faster. (See “The Mythical Man Month”), but a developer who shares best practices with the team and helps them write more flexible, more maintainable, more bug-free code is worth their weight in gold.

Excellent Learner: I frequently tell people to hire passionate learners. The tech world changes fast, and nobody can keep up with everything, but you’ll want developers who can quickly adapt if you decide to make important tech changes. If you want to benefit the most from multipliers, you also need to hire developers who are trainable and eager to learn new things. The best developers are both mentors and mentees — great teachers who also clearly understand that they can learn valuable new things from even the greenest newbies.

Passionate: In order to improve constantly, you have to be motivated to go above and beyond the basic job requirements. You should have a commitment to excellence, and as you get better and gain more recognition, that commitment is rewarded by recognition and job satisfaction.

Passionate developers master their craft, develop a sense of pride and ownership in the work, and they become happier in their jobs.

Many developers have asked me how to become more passionate and motivated. My answer is to get better. Put in the work. As you pick up more skills, you’ll start to enjoy it more. (See “So Good They Can’t Ignore You”).

Trust me, no musician enjoyed slogging through their scales and speed drills until they started to feel their improvement. Few runners loved the feeling of running out of breath until they noticed improvements in their running times, or how far they could run before they ran out of breath.

As we accomplish things, we trigger positive chemical feedback loops in our brain that fill us with a sense of happiness or euphoria. The strength of that effect varies depending on how big the goal was, but even tiny goals can trigger the positive feedback cycle.

In other words, if you’re struggling to feel motivated to work on your coding skills, start with something really simple that you can do in a few minutes, and then build on that. As you repeat the process more and more and tackle larger goals, the levels of dopamine in your brain will grow, and with it, your enjoyment of learning will grow, too.

As you gain more skill, you’ll gain more passion to master the skill.

What do the Worst Developers Have in Common?

Regardless of how many great qualities you have, there are a few negative attributes that can really drag you down. Thankfully, if you’re aware of them, and you have the ability to see your shortcomings clearly, maybe you can reduce the negative impact.

2. Think of the worst developer you ever worked with. Select all the words that describe them.

Incompetent: Luckily, the worst attribute of the worst developers is also the easiest to fix. If you’re just not a very good coder right now, check out “Learn to Code: 13 Tips That Could Save You Years of Effort”, and get to work! If you’re not feeling very motivated, scroll up and re-read the section on developing passion for your craft.

Arrogant: This one is much harder to fix, but simply deciding to make an effort can make a big difference in how other people perceive you. An arrogant person feels the need to puff themselves up, or put other people down in order to feel good about themselves — but it never works. Instead of feeling better about yourself, you may feel a sense of imposter syndrome, and anxiety that other people might discover that you’re not as smart as you make yourself out to be.

Arrogant people often:

• Assume that they’re the smartest person in the room.
• Refuse to explain something because the other person “wouldn’t understand”.
• Talk down to others / condescend.
• Pretend to be smarter than they really are. Frequently Google things in order to sound smart rather than admit that there is anything in the world they don’t know. (Note: nothing wrong with Googling to learn. Googling just to sound smart is a different matter).

Uncooperative: Arrogant people frequently presume that they know best, and when other people are working on a shared vision, and arrogant person will frequently refuse to get on board. If you disagree with something, speak up and be heard, but don’t presume to have a full understanding of all the trade-offs that the rest of the team is considering, and even if you do have a full understanding of the situation, don’t use that to justify insubordination and jerky behavior. Always do your best to be kind and helpful.

Unmotivated: It’s hard to get anything useful done if you’re not motivated to put in the work. Refer to the section on developing passion above.

Stubborn: The reason that I didn’t consolidate “stubborn” and “uncooperative” is that stubbornness isn’t just about cooperation. Sometimes developers get stuck trying to do something that simply doesn’t work. They’ll put days of time into a solution that has no chance of success, but sometimes refuse to admit that they’re stumped. Frequently, developers will bang their heads against a bug that they’re blind to for hours, when somebody else may have spotted the solution in minutes.

Don’t fall into that trap. Be open to the fact that every developer goes blind to problems in their own code from time to time. Every developer struggles. Every developer needs help now and then. Be willing to ask for it, and be willing to provide it when it’s asked of you.

Other Qualities of 10x Developers

In my opinion, you should focus on your strengths more than your weaknesses. Pick 1 thing to improve on this week and focus on it relentlessly. But maybe you’re greatest strength isn’t on the top 5 list. Here are some other qualities that can make a big difference:

Honest, communicative people encourage one of the most important features of any development relationship: Trust.

Often, developers will fall into a trap where they vanish down a rabbit hole for days, and when they resurface, they’ve built something that won’t integrate with the rest of the app, or you find out they’ve been chasing their tail trying to solve a problem that should have taken hours, or minutes.

Communicate, communicate, communicate. Don’t run off on your own for too long. Check in your code every day. Get code reviews from at least 1 or 2 team members. Let your manager know what you’re working on daily.

It will build mutual trust. Your team will get a chance to help you clear obstacles, and they’ll learn that they can rely on you to keep them in the loop and make constant, steady progress.

Efficiency: What strikes me about this one is how far down the list it is. It’s clearly one of the most important aspects of personal productivity, but personal productivity impacts the team productivity a lot less than you might think. To be truly efficient, you need to focus on attributes that will improve your multiplication factor: How much can you improve the efficiency of the entire team? For a lot more on personal efficiency, see “JavaScript New Year Resolutions Countdown”. Particularly Item #2: “Improve Your Development Process”.

Next Steps

As we’ve seen, there are many important factors that contribute to the success of the best developers. So where should you start?

Problem solving ability is the top item on the list. Here are some things you can do right now to improve it:

• Push yourself with some coding exercises. Beginners should check out the JavaScript track on FreeCodeCamp, or the exercises in Eloquent JavaScript. More advanced developers should work on architectural concepts while building practice apps. Always push yourself just past the edge of your current capabilities.

The same thing will work to develop your skills, your learning abilities, and even your enjoyment and passion for code: Practice!

Who could have guessed that all you have to do to pick up 4 of the top 5 most important attributes of a 10x developer is practice?

To fill out the only missing piece, teach what you learn to other people. Answer questions, mentor, pair program with your co-workers, and make sure that everybody on your team is committed to a culture of mentorship.

Share your new found passion for excellence with everybody around you, and the whole team will improve with you.

Not sure what to work on?

Learn JavaScript with Eric Elliott. Bring the team with you!

Eric Elliott is the author of “Programming JavaScript Applications” (O’Reilly), and “Learn JavaScript with Eric Elliott”. He has contributed to software experiences for Adobe Systems, Zumba Fitness, The Wall Street Journal, ESPN, BBC, and top recording artists including Usher, Frank Ocean, Metallica, and many more.

He spends most of his time in the San Francisco Bay Area with the most beautiful woman in the world.