10x programmers are a hot topic to discuss in the software industry nowadays, so thought it'd be a good idea to share my view point in this regard.

Honestly I don’t know the exact definition of a 10x programmer, but I assume it refers to hyper productive programmers (which may not map to exactly 10 times productivity, but to a significant level near or more than 10 times).

Based on few successes I had while delivering ultra-big pieces of software for startups and corporations, and working experience with a few top-notch developers, I can share some insights about this topic.

The 10x Programmer Then

Software developed 20–30 years ago was much simpler compared to modern software, with respect to functionality, security, performance, and scalability. On the other hand, only a handful of libraries or frameworks were available at that time to implement any functionalities.

Thus, software written 20–30 years ago involved a significant amount of effort in programming.

Defining a 10x programmer in that context is comparatively easy. The difference between the amount of core programming effort given to implement the same set of functionalities by 10x and regular programmers.

The 10x Engineer Now

Before going into additional details, lets make one thing clear: software development is a complex process, and programming is just one of the areas to contribute to modern software.

Because of increased usage of software, especially over the Internet, by both consumers and organizations, software is very complex, and it might be an insane decision to build something from scratch. Honestly, unless it's a completely a new platform or operating system, the core programming required to develop modern software is less intense compare to older efforts.

While programming knowledge and effort is still very important, the amount of effort that is required to build great software (bug free, secure, and salable) is in engineering.

So on today’s context, a 10x programmer may not bring much value in the industry, but a 10x engineer creates a very wide impact in the development process.

I’d like to add my 3 cents here.

1. They Make the Best Usage of Tooling

Software development is a complex process, which involves a lot of different kinds of effort. Besides coding, it involves efforts from documenting process, to formatting data, from reading log data, to sending reports, from automatically testing, to manually testing, from complex debugging, to manually investigating issues, and so on and so forth.

A huge effort can be made extremely efficient by using the right set of tools and platforms (that are appropriate to a client's budget and other constraints).

Editors

Writing software involves one or more editors, some of which also referred as IDE (Integrated Development Environment). Modern IDEs, such as Visual Studio or Eclipse, offer a great amount of functionality to make developers productive, but a significant amount of these features are not known by most developers.

Popular IDE’s also have commercial and free plugins (such as Resharper), which enable even more developer productivity.

Besides IDE’s, other editors such as NotePad++, MarkdownPad, etc. are also very useful in a relevant context.

Utilities and Online Services

Utilities and online services such as reading or searching large log files, http debuggers like Fiddler, build and deployment tools, etc.

Own Tools

10x engineers also make their own sets of tools to perform repetitive actions for which the appropriate software may not be available externally.

In lots of cases, business owners in a software development house don’t seem to be interested in investing much on tooling for developers, but using the right set of tooling will enable a surprising amount of productivity.

For software developers, who are some of the most expensive people to hire, spending money on right tooling for them is worth doing.

As a .net developer team lead, developing a ASP.NET Core & Visual Studio starter template following latest .net coding practices helped my team boosting up overall productivity three times.

2. They Don’t Reinvent the Wheel

The software industry has become very mature in the last three decades. Almost every problem that developers are trying to solve by coding has been solved and are available as APIs (either as binary or web services), some of which are commercial, while others are free.

Besides, open source frameworks also provide great flexibility to understand underlying API behavior or customization as needed by the users.

Before jumping into programming, 10x engineers actually make sure this problem has not been solved fully (or partially) before or, if so, they are not available to be used.

3. They (Continuously) Write Beautifully Engineered Code

Writing great software requires defining a good architecture that not only follows good design patterns and principles, but also takes advantage of modern infrastructures. Producing well-engineered code not only enables writing new functionalities faster, but also reduces bugs significantly.

But, beautiful engineering requires continuous improvement.

I’ve seen a surprising amount of low quality code in different software projects in my professional career, which continuously adds technical debt. A simple project that started 5 years ago is full of non-engineered ugly code and requires 20+ people to handle the development cycle (where they are spending 80% of their time actually fixing bugs).

One of the main reasons behind this awful situation, I found, is “fear”.

Organizations, especially enterprise entities, mostly fear change.

Software development is an incredibly fast-changing discipline in terms of tooling, frameworks, and engineering, and requires continuous change to get to the right place.

Change is frightening, but it's not as dangerous as it sounds, especially in the software industry (with the right sets of tooling and people). But if it is not done as expected, it will not take much time for the project to be abandoned entirely some day.