10x Developers

You can’t really type ten times faster than everyone else. It’s possible that the difference between the slowest, hunt-and-peck typist and a skilled touch typist is an order of magnitude, but programmers are not just blindly typing stuff in, so it doesn’t hold for coding.

The software industry likes to deny the existence of 10x coders, but for anyone who has worked for a long, long time, they’ve no doubt encountered them. A small number of programmers just seem to be pushing out way more work than all of the others. Why?

Since it’s not typing, we should narrow it down a little more.

A 10x software developer is at least ten times more “effective” than the average developer. That is, they accomplish more and their work has a much larger impact. They seem to be everywhere, working on all sorts of stuff, and it gets used a lot. The things they have done in the past have withstood the ravages of time, the stuff they are working on now is quite sophisticated.

So, what is it that makes the difference?

From what I’ve seen, they have a lot of knowledge and experience, but also they have exceptionally good habits. That is, a fast and reckless coder might keep pace with output, but their stuff is also a continual bugfest, so as more of it comes out, the deficiencies will multiply. Firefighting then consumes everything.

A 10x on the other hand codes a lot, but the code is good and clean and has very few prod issues. Things run smoothly. So they are able to spend even more time coding. They might not get off the starting gate as quickly as a fast and reckless programmer, but they can keep up their own pace for a very long time, so in the long run they get way more done.

The biggest habit they usually have is the need to fix problems when and where they find them.

Some coders will ignore all sorts of problems and just keep piling on more code, but that higher work is built on a shaky foundation. A 10x will start working, but then Yak Shave into some lower issue that needs to be corrected first. Then they’ll go lower, and still lower. Until the foundations are finally strong. Any code built on top then will require way less changes as the codebase gets larger.

So, the 10xes that I’ve worked with tend to be really slow in the initial stages of the work. But as they ensure that all of the pieces work as they expect, they whip past other developers. The last stuff, on top, comes easily.

You often see it when different programmers work. If they are struggling to set things up correctly in the beginning, they tend to pick up pace at the end. If they race quickly out of the gate in the beginning. then they often struggle at the end, which is also when we are the most tired and it is harder to think clearly about the code. If you have to choose, and you do, it is better to tackle all of the hard stuff first, when you have the most energy. Save the easy stuff for afterward.

10xes usually need things to be very organized. They need it to be clean, and they need to fix all of the other problems first before working their way to the main ones. They spend more time considering what they’ll call stuff, and less time playing with syntactic sugar. They’ll stop and consider future-proofing their code, not just settling on what appears to work today or what they saw on the web. Their speed comes from their need to produce quality work, not just kick stuff out the door.

10xes are super rare, and the industry does a lot to discourage them. Interviews, for example, favor fast and reckless coders with strong memories, not 10xes. A successful answer to some of the interview questions would be an objectionable way to code for actual production.

A software developer might find they are 10x in one organization, but then just be far less in another one, usually owning to the amount of systemic or project dysfunction circulating around them. But they are also affected by life issues and burnout. We code what we know, and if that is impaired for any reason, then our effectiveness is limited.

A good 10x will find a groove and get very solid stuff built. They’ll stay out of politics, and will generally wire their code to be flexible in the face of inevitable scope creep. They’ll use the programming languages well, but not abuse them. They value not just getting stuff to work, but also readability, how it fails, and whether it can be enhanced later.

They know what they know, and will talk about it confidently, but they also know what they don’t know and will tread lightly in discussions. They are quick to admit when they are wrong, and they know they are wrong often. Because of this, they are humble. The last thing they want to do is over-inflate their own abilities, so most of them would never, ever describe themselves as 10xers. They may have been in the past, but there is no guarantee that they will be in the future.

Realistically they alway need to do the right thing. To make sure they have done the best job possible, given whatever madness and impatience surround them. They take pride in their work and it shows. They tend to keep up with the industry gossip but stay out of most of the pointless arguments. They all seem to know that good work comes from concentrating on it, not just flailing at the keyboard and belting out more mindless stuff.