This isn't a post about whether a 10x developer exists or not -- as you may have already guessed, this post's stance is there is such a thing as a 10x developer.
When you read through each answer, perform this exercise: ask yourself how both an amateur and an expert developer might get caught up...and how a 10x developer skates past both.
A typist always beats a non-typist. This is a no-brainer, and a non-negotiable. If you don't know how: learn.
But what separates a 10x developer from other junior and senior developers is their ability to not only produce code to solve problems, but to read / comprehend the solutions that have come before them.
In the real world, developers are constantly tasked with maintaining the work of others. It is one thing to know your own code; it is an entirely different skill to untangle the spaghetti that others have left for you to clean up. 10x developers produce and consume with high efficiency.
- For why the debate over its existence rages, see this post.
- For why great leadership skills have nothing to do with being a 10x developer, see this post.
If you're still reading, you believe! That's a good thing, because it gives you hope that you'll at last get to the bottom of what constitutes a 10x developer.
There'll be a quiz question at the end, so pay attention! Let's get started with a review.
In Review
First, recall the definition of a 10x developer:
A '10x developer' is one that can take software from concept to production-ready in an order of magnitude less time than a peer of matching experience utilizing the same technologies and delivering the same functionality.Cast any other descriptions out of your mind. It isn't that your preconceptions are wrong -- what you think of as a 10x developer may diverge slightly -- but in order to gauge what it takes to be one, we're going to have to agree on a definition. Hence, the one above stands. It is not about amateur hour vs. expertise elitism - it is about measurable proficiency.
When you read through each answer, perform this exercise: ask yourself how both an amateur and an expert developer might get caught up...and how a 10x developer skates past both.
Typist
This should be common sense, yet is often overlooked in 10x developer rants: people that know how to type properly are going to be faster that people who don't. And yes, it is a sad fact to have to admit, but there are a lot of programmers that do not know how to type (and an equal amount that don't feel they have to learn).A typist always beats a non-typist. This is a no-brainer, and a non-negotiable. If you don't know how: learn.
Problem / Solution Fit
10x developers have the ability to examine a problem and see where previously applied solutions would do well. There is a lot of time and energy wasted in building solutions from the ground up (and programmers especially love to build their own stuff vs. work with/maintain other people's stuff). 10x developers have markedly shorter turnaround times because they aren't constantly reinventing the wheel.
FizzBuzz Comprehension
Jeff and Joel famously claimed that the single best way to interview a programmer was, instead of having a candidate solve some abstract complex puzzle (worthless), the candidate should instead be asked to implement a very simple, rudimentary piece of code. You may think this only weeds out amateurs. Not so. Many a Comp. Sci. grad can fall into this trap as well.
But what separates a 10x developer from other junior and senior developers is their ability to not only produce code to solve problems, but to read / comprehend the solutions that have come before them.
In the real world, developers are constantly tasked with maintaining the work of others. It is one thing to know your own code; it is an entirely different skill to untangle the spaghetti that others have left for you to clean up. 10x developers produce and consume with high efficiency.
Distraction Free
If there's one thing a 10x developer cherishes, it is flow. Clamping a pair of headphones over their ears is the same as hanging a DO NOT DISTURB sign outside their door. In a landscape of open office plans, Lumbergh-style managers, needy fellow employees in a Slack channel and the constant blip of social media alerts popping on their phones, a 10x developers has practiced and developed the discipline necessary to stay focused on a task.
We could debate for hours where the responsibility in curtailing distractions lies (bring it!) but for now, let's be clear: regardless of distractions (or who caused them), a 10x developer can successfully tune them out.
Tool Proficiency
If you've got a masochist on your hands who lives and dies by their vi editor, hey...more power to them. But are they compiling by hand? Are they linting? Do they deploy their builds manually? How are they debugging? How easily can they move between bug fixes and feature requests? Where's their code stored and can their changes be recalled historically? Many expert developers claim they still look code up (perfectly fine!) but how do they look it up? More importantly, are they leveraging any sort of programming tool that might look it up on-the-fly?
Both amateur and expert programmers alike have tools and processes they prefer. But a 10x developer is not wasteful when it comes tooling. They will automate what they can. They take advantage of IDEs that guide their development. They take the time to build the necessary infrastructure that allows their development processes to scale.
A comment debating the existence of the 10x developer recently made the claim that this was illogical when comparing to other industries, positing "how can can a construction worker be 10x faster than another?"
Simple: Construction workers don't bash nails in with their bare fists...but using a hammer and using a nail gun produce vastly different turnaround times. 10x developers know this secret and leverage tools appropriately.
Troubleshooting Strategy
Fixing bugs is a part of every programmer's life. The efficacy of each programmer's problem solving technique can vary from person to person. When it gets down to the line-by-line examination of faulty code and its matching bad behavior, 10x developers look to diminish the impact the malfunctioning system has on its customers.
If an urgent system is offline, a 10x developer knows what steps to take now vs. later to resolve the issue -- a key differentiating factor from an expert, as some "experts" will always insist on the full end-to-end solution, keeping the system offline in the process.
I once deployed a bug fix that caused some dependent systems to behave badly. Thanks to behind-the-scenes logging, I was able to assess the situation and identify a bug fix pretty quickly. Once I was ready to push it out, however, I was stopped dead in my tracks by a DevOps team that insisted on rolling everything back and starting an entirely new build. When I attempted to communicate that the rollback impacted database schemas, risking additional hours of downtime -- while my fix would deploy in seconds, someone on the conference call pushed back, claiming:
"Uh, this is IT 101 folks"
No. "IT 101" is evaluating your options to determine the least amount of impact to your customers. If given the option between online now and online hours from now...you get it online now, and make the next step your long term fix. Process is great, but not if it gets in the way of progress.
Remember, kids:
- An amateur band-aids over a problem.
- An expert applies a solution to a root cause.
- A 10x developer gets the system back online.
Quiz Time!
Let's see how closely you paid attention: What's the one thing in common with all of these traits?
Answer: all of these traits impact turnaround time:
- How fast one codes.
- How fast applies existing solutions to new problems.
- How fast one converts a business challenge into an algorithm.
- How fast one gains (and retains) flow.
- How fast one can "build to production."
- How fast one can get an unserviceable application back online.
And remember...It's not just about speed, it's about how long it takes someone to produce quality output and call it done. In some cases (like typing) yes, speed of execution matters greatly! But with others (such as building to production) its about enhancing one's ability to perform the task (ie. via automation) that separates 10x developers from the rest.
And here's the other secret: there are actually plenty of 10x developers out there. You know what they call themsleves?
"Developers"
And the reason why is: their accelerated turnaround times don't emerge until their compared with slower folks that:
- Can't type,
- Don't have the experience / skills to apply old solutions to new problems,
- Have never practiced converting business challenges into code,
- Lack the ability / skills / concentration to enter distraction-free flow,
- Don't know how to automate their processes,
- Are focused on bug fixes rather than system uptime during a crisis.
But now that the bullet points are as plain as day, they can start now. And so you can you.