So does anyone else agree that there are actually 10x (or more) developers? This is a pretty good example of how one works.
@jamii seems super talented, but his bio says "in the past I've built database engines, query planners, compilers, developer tools and interfaces for [a...] myriad [of] consulting and personal research projects.", along with his repo's being related to SQL parers, or literal text-editors working purely on string manipulation. He is also sponsored to spent 100% of his time doing exactly this.
What I mean that he is almost definitely a 10x dev at writing SQL parsers. But ask him to write a shader that renders a neat waterbed material and he'd be likely a 0.8x dev? The overlap between experience and context is key.
That said, I can't think of any technical domain where I could do this, even if provided with all the tests up front.
My experience with the phrase is people mean finding a "diamond in the rough" who can code circles around anyone else. It's not about finding a Norvig or Carmack, it's about finding a fresh graduate that you can stick on a problem and they will be bountifully productive.
It's basically a manager's wet dream: extremely productive but cheap. In my experience real 10x people appear to be the opposite: seemingly slow but incredibly expensive. Everyone I actually consider 10x makes millions. And of those that are friends, they didn't really reach that 10x stage until their 30s or 40s.
It's something you get from other people. There's not a good test to figure out if you're 10x better than some randomly picked average developer.
What fraction of devs could even complete this, let alone in merely 10x the time?
I think the actual pushback of the 10x programmer idea is that it's more often used to bully regular programmers into working longer hours, rather than actually identifying top performing programmers.
Like 25%? But that’s really only because of the influx of people doing it for money.
If you’d asked me the same thing 15 years ago I’d have said 80%.
If you also don't follow specific developers online then you might not notice any. Here are a few I've seen for which 10x is probably an underestimate!
* David Tonlay and Alex Crighton - feels like they've written half the Rust ecosystem between them. * Eric Traut (Pyright author) - seriously go and check out Pyright's bug tracker. It's insane.
I think it would be more reasonable to call someone a 3 -sigma dev (someone 3 standard deviations above the mean. These would exist because that's how stats work)
The gambit is that a mediocre programmer would take 10x as long to write the same code as the hypothetical 10x dev. But that’s not what a mediocre or even average dev does: they solve the problem in an entirely different (and, for purposes of this argument, less optimal) manner in some spam of time that may or may not be longer than a qualified hacker or a theoretical 10x dev. Almost all CS problems have multiple solutions, so you’re not likely to find one where there is only one solution and it takes one guy x and the other guy 10x as long.
Also, you're not guaranteed to have an example 3 standard deviations above the mean. It strongly depends on your distribution and sample size.
You're right about the sufficient sample size.
To me, the more likely explanation is that this guy is an excellent developer, working on a problem he was suited to, and that's about all you can say. He came up with good strategies and insights here, and worked hard, and did a lot of other stuff right. But the idea of a generically 10x developer is a cartoonish oversimplification of how the world works.
I also propose that moniker be banned from being self-applied, and is in fact, a smell test: if you encounter a colleague calling themselves a 10x developer, start interviewing immediately. No good will come out of that.
The majority of the team couldn't understand his code. We'd have newly hired senior developers just leave rather than deal with it.
He'd rolled his own code generator for our data model that did everything from model generation to the web controllers.
The result was that while he could pump out work quickly, what would've otherwise been a quick fix for a graduate developer now required a deep understanding of a complex system.
This had the effect of turning what would have otherwise been a team of 1-2x developers into a team of 0.2-0.5x devs with a retention problem.
Anytime he "improved" a module, no one else could maintain it as that would entail additional rule-breaking, which was verboten for mortals, so only he could maintain code he touched. Combined with the fact that he didn't add any tests: the net result was he was slowly and surely subverting the codebase into his personal, brittle domain that no one else could change. He was slowing everyone else done, but all management was looking at was his velocity at closing bugs or rolling out new features while creating tech-debt. His boastful personality was just the icing on the cake.
There was a great deal of thought put into it and he could extend and modify the output really quickly.
The complexity of the system basically made it so that what would otherwise have been a simple task achievable by a graduate required a deep understanding to carry out.
Heh, I've actually done that... twice. Luckily it was a team of 1 and I wouldn't expect anyone else to understand my mess. The code generation was extra ugly since I planned to get rid of it eventually to craft out smaller details. It was great at doing repetitive work in bulk. Not sure if it was actually faster but at least it was less boring doing things that way.
The difference, of course, the framework has extensive documentation.
So that was the missing ingredient.
He made a framework, but wrote no documentation. Writing documentation would have made everyone an n*x developer, for some value of n > 1.
Also, it's good if language doesn't stand in your way.