The Power of the 0.1x Developer: Unsung Heroes of the Codebase | Hacker News Reader

The Power of the 0.1x Developer: Unsung Heroes of the Codebase

medium.com

23 pointstomerbd29 comments

The 10x developer was never supposed to be "churning out code at breakneck speed" or "leave a trail of destruction in their wake", except for maybe some misguided recruiter/manager/CV-padder. Saying that they are is an easy strawman argument since we all agree no one wants those.

When you think 10x developer, you should instead think about devs who built industries, or devs that made such huge impact that them being human has been questioned. Widely known examples might be: John Carmack, Linus Torvalds, Joel Spolsky, etc. For industry-specific ones, in JS-land you could think of TJ Holowaychuk or Sindre Sorhus. And for quantifying it a bit from the "business" side, think that Instagram reached 14M users with 3 Engineers and Whatsapp supported 450M users with 35 engineers. For a more general view, "/fast" is a great read: https://patrickcollison.com/fast

What did Uncle Bob do, besides being good at marketing?

Teach generations of developers how to make their code better, making the whole industry much better than it'd have been otherwise. A 10x dev IMHO is not only great coding, but makes everyone around them better. Now that said, I'm going to edit to change him for Linus Torvalds, since you are right that he might not be the archetypal 10x dev as he's not famous for his code, but for his writings.

Yes. 10x can also be by being good at explaining things, and raising the ability of everyone around. The 10x also Increases the skill of the entire team.

How long have you been programming? Odds are Martin's been doing it longer. In fact, my understanding is that if you're the average dev, Martin was consulting with companies that found him valuable longer, and developed for longer than that.

I've never understood this insistence some people have on outright refusing to acknowledge someone who wrote a styleguide they disagree with have the ability to turn on a computer. This isn't just in reference to Martin, either, and it's doubly weird because half of them seem to rest on describing style as mostly to entirely subjective in the same breath. It's just a book. Merely don't follow it and it can't hurt you, even if it's somehow "the one wrong preference". It's not going to kill your cat.

Lots of people have been programming for longer than me, that doesn't make them all questionably human 10x developers.

Keep moving those goalposts. It really makes you look like the reasonable side of this conversation.

Joel Spolsky more feels like a good dev (median skill) that is really good at writing blog posts.

He had some pioneer ideas about automatic micromanagement by Jira-esque velocity tracking tools. A sin he got way to little critique for.

Carmack is probably the archetype of a 10x dev and like any real diva he seems very toxic to work with. Dunno if you'd want him unless you are writing Doom before 3d games were a thing.

From all his public talks, Carmack seems like a nice and smart guy. I’m curious why you have a negative impression.

It is just the feeling I got from reading his dev. diary. Nothing but a feeling that I don't want to work for him.

Elon Musk seems very timid and shy. I was surprised when watching the "steel ball fail". He was nothing like what I imagined him.

It is really hard to tell people characters by video appearances.

In the book "Masters of doom", at least during the doom era, Carmack seemed like a really bad collegue. Very, very demanding and complete lack of social tact. The book gave the impression that he wanted everyone to be as commited as him, and his commitment was extreme.

Obviously this was a few decades ago.

This article is uninformed nonsense, as per usual on this topic. When the 10x study was published, it referred to tested, quality code (and assembly code, at that). Reminds me of another article from a while back where a 0x engineer who spent his time on other maintenance, code reviews, and testing without logging his work one sprint made similar complaints about wanting productivity, as if the rest of his team thought freeing up their time to develop their task was reducing their velocity somehow. At best this type of glorified blogspam is clickbait, and at worst it suggests a strange desire to disregard hypercompetence instead of trying to learn from and emulate it.

And besides, if it genuinely (again, clickbait) takes you 100x longer to code something with tests as it does your colleague without them, there might be something deeper going on there. It could be worth trying to learn from them anyway, even if their code has a few bugs you would've caught.

Speed up gains in development are not just a matter of how fast a coder can achieve a task compared to another worker, but how a certain choice of architecture can enable these gains to be collected again in the future for anyone working on this codebase. If you managed to make a certain task completable 10 times faster and this task will be repeated n times in the future (for instance implementing an API route on a server), you end up with a "complexity" of n versus 10n. Of course it requires making code investments and these decisions should be made by assessing whether it is worth it with respect to n (whether YAGNI). The true "10x" improvements are to be found in the compilers and frameworks you use, now the question is whether your 0.1x colleagues would be comfortable working with tools whose implementation overwhelms them but still allow them to get a 10x speedup.

Again, my understanding is that the 10x study was done on reviewed devs writing necessary and best-practice code in a cooperative setting with the same tooling, so this is still irrelevant to discussing the topic. Of course no one who wants to encourage velocity thinks you shouldn't invest in tooling that will automate long tasks for you. We should learn and cheat. My irritation is with suggestions that there's nothing serious to learn, not that I think there's nothing to cheat on, which is an unconnected topic anyway.

It’s an interesting conception of the 10x developer, but I feel like the 10x developer is just someone who does what the 0.1x developer here does, but 10x faster. It should mean excellence in all respects, just 10x more of it. That’s what we’re x-ing, not just raw lines of code per hour.

There’s truth though about the “leave a trail of destruction in their wake”. I worked around a guy like that at Airbnb. It was a very consensus place then, and getting everyone around to agree to do stuff took forever. So, if some guy can lie/bully/cheat to do whatever they promised management, yeah, they do get more done. But it’s indicative of a sick organization, there was an HR investigation of his abuse, and everyone who knows anyone this guy burned has him on their do-not-hire list. I heard at a party he joined a company I had on my interesting-companies list, now it’s on my never-work-there list.

"someone who does what the 0.1x developer here does, but 10x faster"

wouldn't that be a 1x developer?

I absolutely agree with the point being made here, but I don’t think you’ll get much gratitude from the industry as it exists today.

This is a move-fast-and-screw-the-next-person industry. Usually that’s because of non-technical decision makers who believe if their boxes are ticked then all other things are equal.

Sometimes the other things don’t matter - some work has a very short intended lifespan - but for anything long lived there’s a reason why you’ll see the same mess everywhere.

I worked a gig a while back where a monolith was being replaced with a lot of really granular micro-services. The relatively young developers did so much bitching about the monolith before I got to look at it that I thought it would have been a disaster. It had transactions for everything, comments, levelled logging and really strong unit test coverage. The new system was already a tangled mess of unversioned javascript with no documentation at all and it hadn’t even shipped yet. The single source of truth for a single component was, without exaggeration, whatever the last person to work on it said it was.

Great might be the enemy of good enough, but inadequate houses of cards seem to be what the industry keeps voting for with their wallets.

The 0.1x is the 10x developer. Slow is smooth and smooth is fast.

Context matters, and businesses all have their own contexts. But in general, what you refer to as "0.1x developer" is what generally is understood as the "10x developer", and your description of the "10x developer" feels more like overconfident and unguided jr-mid level devs.

It's easy to step into the trap of thinking lines of code written, or amount of commits pushed are a benchmark for a dev's productivity. Reality is, the greatest devs build a stable product that leaves everyone's pager silent even on peak usage, lets new contributors be productive quickly, and cause no blockages along it's development.

This guy lost me when he made it about himself. It just sounds like a bunch of "I'm not like those other devs".

The conclusion from the top of the article is basically "why im better than those silly 10x developers"

Also this guy thinks his crap doesn't stink somehow.

Something about "I focus on making code that other's can maintain".

I enjoy the premise of being the 0.1x developer as this post says but in the real world we face real problems. That impossible deadline given to the 10x dev? That's probably for a reason. The world moves fast and more importantly it doesn't work for you. So you need to meet other people's expectations until the day you can afford to say no.

In fact if the author is here, the reason one can be a .1x dev is because the real work is already done by the 10x guy/gal (we'll refer to as X). Without X the product might even not exist or the entire company and your job.

The way this article is worded is also making me feel like the author has this self doubt about his productivity or someone questioned him about it. His ego doesn't want him to improve but push harder to be 0.001x and look for validation.

> Have you inherited a codebase written by a coding rockstar. It works, but it’s a tangled mess.

Have you ever inherited a codebase written by a 0.1x developer?

Genuine question, I never have.

I have. It was a pile of “serverless” crap. Zero tests. No ability to run locally. Few comments. Copy-pasted code everywhere. Productivity was incredibly low since people edited code in the AWS console.

I think you misunderstood the question and/or the article

Maybe you misunderstood my answer. I was answering the question in terms of what I consider to be a 0.1x developer. They are not fast and they don't get things done.

Cool stuff.

yes

no tests, giant byte arrays being used for global state instead of objects in scope defined classes (with associated reuse bugs everywhere)

same thing copied and pasted 40 times with slight modifications for no obvious reason

copies of variable named "more" or "2" because they didn't know how to grow data structures

and then add multi-threading into that

It’s a shame that most comments here are debating the meaning of “10x” and rather missing the point of the article. This one spoke to me completely outside of this productivity distinction. I’m forever finding myself doing the same; trying to rationalise dev envs, the write-once CI code that nobody will touch, or fixing egregiously bad tests. The author is right; nobody will thank you for it but it’s also crucial.

> Have you inherited a codebase written by a coding rockstar.

This 0.1x dev, with huge attention to detail, misplaced a period for a question mark.

Reply on news.ycombinator.com