10x

Introduction

There has been much written about 10x developers over the years. People argue, sometimes viciously, that there is either no such thing, that it's a Myth, or that the phenomenon clearly exists and there is evidence to support the claim.

The nature of software development is that it's unpredictable knowledge work, and that it's usually designed and built as part of a complex system. Given this, I suspect it's impossible to 'prove' either way whether the claim is true or not. Regardless, I wanted to write down my thoughts on this.

Logically, 10x developers are possible

If you claim something exists (e.g., a yellow teapot on the other side of the sun), the onus is on you to prove your claim (for all cases). If you claim something doesn't exist, then the challenger only needs to show one example to disprove the claim.

Clearly, if someone cannot program, then they are the zero times developer. Compare the non-programmer to a programmer, and the programmer becomes an infinity times developer. It is reasonable to assume that productivity, while it can't be measured, is a continuum. So if the multipliers run from 0 to infinity, then at some point the 10x multiplier exists.

This is not a useful measure though. On any given project, with a team of experienced programmers, you might hope not to see a difference in productivity of 10x.

Anecdotal example

There was a project, and the project started by gathering requirements. The business stated it needed an online report from each of its departments to monitor how they were doing. The data for this was already stored in their internal application, so this was 'simply' an exercise in extracting that data and producing a report.

It turned out some of the data was not entirely accurate, so the business needed a way of altering some of the data on the report to remove anomalies. It also turned out that a small number of the (large number of) departments weren't using the internal application, so the business also needed a way to manually enter the figures for those departments.

There was more than one person gathering requirements. The requirements gathering was passed about the organisation like a hot potato, with each person begrudgingly adding their small additions.

By the end of a few weeks, the requirements had grown to look like someone was trying to implement Excel in the browser!

Then one developer said "why don't we just export the data for a department to CSV, and the business can import it to a spreadsheet to do whatever they want?" The business was happy with this, and ecstatic to not be paying a sizeable sum to develop the software.

Some points:

• This saved a lot more than 10x the cost of development;
• While this looks obvious in hindsight, it wasn't obvious to each person inheriting the project;
• Although a developer suggested this, it could have come from anyone.

I think it's not always easy to see the 'obvious' option when you're entrenched in a potentially bureaucratic project.

Decisions

While the above example is extreme, my guess is that a lot of decisions we think of as straightforward could have a large impact. We might choose a technology that is not suited to the problem at hand. We might find, many months into a project, and with no way of predicting it, that the provider of the technology stack we chose has gone bust. We might find that the city we started a project in was about to have an outbreak of some hideous disease.

We might find none of these things, and that collectively those decisions saved the project/company a lot more than 10x.

It's easy to dismiss this as chance. I suspect some of it has to do with experience. Maybe.

Conclusion

As mentioned, I suspect you can't prove that someone is a 10x developer. My suspicion is that, rather than 10x developers, there are 10x decisions. My suspicion is, that on a reasonably complex project (and there's not many simple ones), there are lots of 10x decisions being made. Possible every day. Possibly without anyone even knowing.

I don't think we'll ever be able to prove that 10x decisions exist. I suspect they are common. We can only continue to try and make the feedback loop shorter to root out the poorer decisions earlier rather than later.