One of Marc Andreessen’s most quoted statements is “Software is eating the world“.

All that software has to be written by someone (or something in the case of code generation).

There are a lot of software developers and they come in a wide variety of skill levels. The question as a business owner or software development manager is how do you find developers that are 10x better than average? After all, no one wants to pay a beginner developer to learn their craft. The 10x developers are those that can move a project or, in some cases, a whole business forward. They are able to far outproduce average colleagues in both quality and quantity of results. And, for the enterprise that hires them, they are a far better value. To borrow a phrase from the old TV show Kung Fu, they are able to walk on rice paper.

So what are some characteristics and habits of 10x developers?

Here are 12 that stand out to me.

1. They regularly engage their customer

Working closely with the customer is an essential help in avoiding building exactly the wrong thing (and thereby having to re-write it). The 10x developers I have worked with are effective at keeping the customer in the loop of development (even before agile) to make sure that what they implement will meet the customer needs without significant re-work.

2. They are a master of their eco-system

Whether your environment is enterprise Java, embedded systems in C with a custom RTOS, web delivered apps with a PHP or Ruby framework or some .NET application there is an eco-system to consider. That eco-system is the sum total of the environment that your application is built and operates in. For example, when writing real-time embedded software, you had to master the compiler/linker tool chain, the RTOS environment and the specific hardware and sensors that you were working on. The 10x developer understands the pieces of the eco-system, how they work, how they fit together and how they impact the code.

3. They are a native speaker of their language of choice

The 10x developer is a fluent speaker of their language of choice. Bruce Eckel has written a  couple of books where the titles begin with the phrase “Thinking in”, like Thinking in C++ or Thinking in Java. That is literally what 10x developers do. They have the bulk of the core language memorized. When they sit down to code, that language flows out of them like water from a mountain spring.  Native language speakers can be more expressive and idiomatic in their implementations. They know the right built-in function.  They know whether it is …(needle,haystack) or the other way around. They look at the language manual when they need to but that is not often. And, for languages that continue to evolve, like  Go, PHP or Swift for example, they keep up with the changes.

4. They write maintainable, extensible code

The 10x developer writes code that is clear, modular and straightforward to extend. They document consistently. They communicate intent with their classes, methods and variable names. There is little ambiguity in what a method or class member does. They produce code that is usually fairly intuitive. When you open the files produced by one of these folks you can say a professional has been here.

5. They write code that lets you know what went wrong

One of the most time-consuming activities of a developer is trying to figure out what went wrong when code execution fails but does so with no trace, clues, breadcrumbs, log entries, exception stacks or the like. A 10x developer will leverage language features, like exceptions and logging libraries that allow them to communicate what errors occurred and their context.  This leads to quicker resolution of problems.

6. They develop their own stockpile of snippets and utility code

One 10x developer that worked on my team showed up on their first day with a hard drive full of their personal code of libraries and utilities they had written.  That fact allowed them to move very fast. No re-inventing the wheel. No figuring out how to re-write some basic algorithm or library. They brought tools with them.

7. They master the tools they use to produce the code

Maybe you are ‘vi‘ person, or emacs. Or, you could be a NetBeans,  Eclipse, or Visual Studio user. You might be a PHPStorm or PHPed expert. How about Sublime Text or edlin (just kidding)? Notepad++ anyone? Or any of the other hundreds of other great tools. Regardless of their tools of choice, a 10x developer has a toolset they like, have mastered, have customized and that allows them to turbo charge their output. On one team I led, I had a developer that was an emacs guy. He could make emacs slice, dice, julienne and dance on a pin. It was fascinating to watch him code and edit with emacs because he was so fast with it. That mastery gave him a significant advantage over those who were just average with the tools.

8. They leverage frameworks

I know, some of you are thinking, 10x developers don’t need no stinking frameworks. Yeah, well, maybe. Modern frameworks provide so much functionality and give developers so much leverage in speed of creation of complex apps that they cannot be ignored, especially if you care about time to market. 10x developers with mastery of say Ruby on Rails, or Django or Laravel can produce web applications with remarkable speed. Fully functional, complex web apps. The extensive API’s of Java or .NET provide astounding capability that a 10x developer can leverage to further accelerate development speed and leave their parochial, framework-less teammates in the dust.

9. They code idiomatically

Every language has its way of doing things. In the Python community you see mention of doing things ‘pythonic‘ which is a reference to doing things in a native python language way.  When I first started writing python, I came from a C  background. It was amazing how much like C my python looked. But that was not idiomatic python. I had to learn to use the constructs of the language and the libraries natively, the way they were meant to be used. By doing that, I would take what was 20 or 30 lines of code and make it 5 or 6.  10x developers do exactly that with their language of choice. And it accelerates their results.

10. They code with secondary effects in mind

Any code written will eventually have to be executed. It will take up memory, use system resources and impact other programs in shared environments. 10x developers write code with these secondary effects in mind. How long a transaction should take, how much extra memory an algorithm extension will use or what additional cpu will be taken if we increase the message throughput are sample considerations in this area. A 10x developer will gain insight through testing and experiments that will build intuition for future projects. They code so as to eliminate as many secondary effect surprises as possible.

11. They don’t repeat themselves

You can spot the code of an amateur easily.  Repetition. You see a lot of cut and paste evidence throughout the code body. When noobies need to do the same operation they cut and paste the few lines of code needed instead of stopping to make a method or function to do the job. This practice adds bloat, decreases maintainability and reduces readability in many cases. 10x developers modularize their code and have effective class structures so they don’t repeat themselves.

12. They make effective use of SCM tools

Software configuration management tools are the backbone of any successful longer term development effort. Tools such as Clearcase, GitHub, SVN, or Perforce are essential to tracking, releasing and maintaining any software project. Features such as tagging, branching, merging, and finding the accurate delta between two releases are crucial to a high quality developer and nonnegotiable for a quality software team. A sure sign of a beginner is keeping code in their home directory or desktop and making a new file or folder copy each time they make changes.  A 10x developer understands the SCM tools they use and leverages them to precisely know what they did, when they did it, what it affected and where it went, very quickly.

Certainly these habits alone won’t make you a 10x developer. However, they will take you a long way down the path. If you incorporate these habits and characteristics in your coding practices you too may one day walk on rice paper.