* Documentation
* The debugger / print()
Becoming a 10x developer means that you have a set of skills that work well together in an end to end process from going to initial requirements to fully fledged architecture and/or code.
That's not what I think 10x'er is though. I think a 10x'er is someone who enables the 'average' developer to become a 2x, 3x, 4x developer. This can be through writing some core tech, a library used by all, or through mentoring and guidance. The 10x'er can then become a 100x or even 1000x developer. The 10x dev is the person who picks up the really difficult or ugly stuff and says: "Hold my beer, I'll get that done" - motivating the team and helping them to keep velocity. They lead by example and explain to the team why they've taken the approach they have.
Sometimes people use the term Rockstar to define a 10x developer. I think that's a loaded term that comes with an 'arrogance' tag. The true 10x developers shouldn't be arrogant (beyond the base level arrogance everyone of ability has), they can and should be the glue that holds a team together and helps everyone achieve more.
Developer: a person that creates software.
10x development: a person that does it 10x faster.
What you describe, I'd simply call a lead developer since making other developers 2x or more is a lead developer his job.
If you're a developer and you're doing this, then it'd be one argument to get promoted to lead.
Also, if you really are a 10x dev, the one I know works in the HFT space. He's making bank. I'm not sure if that's your thing, but I've noticed they seem to appreciate 10x devs a lot more than any other company out there (and that includes FAANG).
If he was to just write code he'd be a 10x'er, with the other work he does to help his colleagues, he's many times more than that.
The problem with that definition is that it tags the coveted 10x label onto the problematic cases mentioned in the article: that guy who is able to hack together POC code that he demos and passes off as the solution, but requires a whole team to fix and to rewrite and to rearchitect to get it to actually work and be production-ready and be maintainable.
Inadvertently, this means that we see the 10x label being tied to observable behaviors that are actually a productivity nightmare just because they go from zero to demo in record time.
Well, speaking honestly probably more like 5x, but it would take a solid 5 person team working well together to do the same things he did.
His ability to reason about the problem- get to the root of the persons actual issue, proof of concept intitial revision and iterate until it was better quality than most popular open source projects was honestly awe inspring.
His only problem was his own lack of self confidence. He used tools and always asked if they were really the best or if he was inflicting them, had good reasons for not using things that we consider industry standard (he prefers restructured text over markdown because it’s more expressive, for example) but was ultimately very sad about every project he made because he felt like he had inflicted his (good) work on the world.
So, idk. The people who think they are rockstars probably not. He definitely didn’t think he was but he was a god to me.
> The problem with that definition is that it tags the coveted 10x label onto the problematic cases mentioned in the article: that guy who is able to hack together POC code that he demos and passes off as the solution, but requires a whole team to fix and to rewrite and to rearchitect to get it to actually work and be production-ready and be maintainable.
As I said in another comment. I've met one 10x programmer. So I consider him to be the archetype 10x programmer since he's the only visible proof I have. We're good friends, we mostly talk about life. I sometimes see him code. Let me assure you, he is the last guy that would hack together POC code. I know this, because I'd be one of the first to do that and he gives me a lot of flack for that when I show it to him xD
I should have left out the "or" in my definition. He knows how to architect, he knows how to code, he micro-optimizes every nano, is capable of understanding how underlying ISAs are doing their thing. He knows how to reason well. At companies where he'd enter as a junior, he was immediately recognized for having better technical skills than people 10+ years their senior (note: not his social skills, those are simply normal).
They exist. And it's easy to see why 10x programmers exist. Take a bell curve of ability and you find many 10x'ers on many scales of ability.
Or would you argue that people like Einstein was not a 10x physicist, or that Euler wasn't a 10x mathematician? And there are many more that I wouldn't even know of.
10x programmer is very related to the idea of a genius, in my opinion. It's simply a subset of it.
Feel free to disagree. It's good to see other perspectives.
And for that task, factors like how well a developer knows the libraries, how fluently they can express themselves in the language, how fast they can type, how seamlessly their mental model fits with the tools available.. all of those things can make the difference between it being something one dev can crank out in a couple of days, and another dev takes a few weeks over.
And I definitely want more of the first kind of dev on my team than the second kind.
But here’s where that doesn’t match up to what we expect of lead developers and more senior devs as their careers advance, and why ‘10x’ is not necessarily an indicator of ‘ready for promotion’.
The person who can see the whole problem and turn it into code in 2 days often struggles to figure out how to scale what they do to more people. They can’t express how the code should work to someone else because they’re already three steps ahead - explaining how it needs to be done will take longer than just doing it!
So the problem is as soon as this person encounters a problem that is too big to fit all in their head and crank out in a few days, or that requires expertise they don’t yet have, so they need to collaborate… the approach they have learned to rely on stops working.
But it turns out there are 10x team leaders too - devs who can break large projects up into chunks that can be delivered separately, who make sure the team is building the right thing, who know how to make use of that individual who can just crank out a complex system in a couple of days - repeatedly and sustainably - and who make systems that are the right shape so that later features are cheaper and easier to add, rather than becoming harder and slower. In fact at this level the multipliers go way beyond 10x.
And some of those skills build on the individual 10x dev skill set but some are orthogonal to it. Some are downright opposed.
