Hacker News Reader

I don't think I'm a 100x developer or anything, but I think people underestimate the compounding interest of being a 5x-10x developer. If you architect things just right today, that can save you a lot of time tomorrow. Spending time testing today can save weeks of bug time later, which can be spent to create something useful, compounding on itself.

If we say green field is 10x, and someone is doing good things, I think that should go up over time. Getting things like builds, documentation, tests, make people more productive.

Whereas on the other hand, people who make code worse eventually start drowning in their own filth, and eventually slow down to nearly nothing. Filth also compounds.

I was involved in an accidental situation where two teams at different companies worked on the exact same project from the same starting point, each led by different developers. This was not the company's core product, but a necessary part of it (for anonymity, let's say this was the device driver for a fancy piece of hardware).

The lead developers on each selected different frameworks, used different data architectures, and set up different workflows. One project became hugely convoluted, with bugs that were very difficult to trace due to race conditions, the way the navigation worked, and choices that let to more complex code. The other team had a much simpler architecture, and was literally 95% less code. That team was able to add new features with ease, and without complex bugs cropping up out of nowhere.

In fact, that project went into "maintenance mode" because there was nothing else to add, and the lead developer could just add one or two minor things when they cropped up, and instead spent most of his time on a new unrelated project. I'd say the lead developer with the better architecture was not only 100X, but the other team's lead developer would probably lead to the downfall of that company -- both morale and development speed would plummet to 0.

Yes - excellent developers are a productivity multiplier.

It’s not about the 12’o clock shoot-from-the hip duel - the one who shoots more codepoints in the general direction leaves winner.

A piece of code - if it ends up in production - has so many potential ways to waste work hours that avoiding just a fraction of them is a huge win.

Yes, and not just hours of work, but reputation damage. Think of all the products out there where people say "but it sucks because it crashes for no reason sometimes." These are not reproducible crashes generally (as most developers can fix those), but rather bad developer decisions that led to a system that is hard to make bug-free due to the way it's structured. Even the decision to use a programming language without pointers can lead to fewer unexplained crashes, security vulnerabilities, etc.

What was the outcome? Did the convoluted project get abandoned?

This is an interesting story. Was wondering if you have it written up somewhere so I can cite it? If not, perhaps you could mention how you’d like for it to be cited, thanks.

On a lighter note your username definitely checks out :)

Yes, but I don't think it compounds forever. There is a natural thermodynamic limit somewhere. In practice if your company has a 1x code-base you are working for a decent company. If your company has a 5x code-base, you are working for a world class company.

EDIT: On the other hand, there is no limit in the other direction and that is where companies end up in big time trouble with a 0.01x codebase.

It's true, it doesn't compound forever, I think because eventually it is finished, and you don't want to add things to it. I think knowing when something is finished as opposed to adding yet another tool on a swiss-army knife is also an important skill. Otherwise you end up with a swiss-army ball of mud.

I'm also going to go out on a limb and say there's such a thing as a negative codebase. For example, let's say I have to work in a codebase for a particular political reason, and I can't rewrite something. But if that takes me 100x the time it would to do it correctly, then really the codebase is actually a net negative. One example of this is places that use an in-house framework for something (when there isn't a good alternative), but then a good open source alternative comes around. Of course you don't want to rewrite things all the time either, so I do agree there is a limit, but really I think that comes down to the code doing exactly what it should in the least complex way possible (with no bugs). Once you get there, there's nowhere to go?

There's a big difference between making obvious mistakes that make everything worse and making the "right" decision for a future consideration. Beyond first-hand experience (i.e. making the mistake and then recognizing it in a future, similar decision) I'd say even the best "architects" have about a 20% success rate when moving into uncharted territory. Planning for tomorrow at a strategic level is hard.

> but I think people underestimate the compounding interest of being a 5x-10x developer. If you architect things just right today, that can save you a lot of time tomorrow.

I'd also argue that a lot of people over-architect solutions and they miss out capturing markets, which leads to real life economics for a business. YMMV

Exactly how I see it.

Good code builds and compounds on itself. It makes every developer on the team more productive. Its not just about the output of the single "10x" developer. Just having them on your team increases your whole team's output, even after they've left. Sometimes other "10x" developers build on top of that work.

Bad code also builds and compounds on itself. Same argument but in reverse. At some point the codebase becomes so unwieldy, someone will have to convince the manager, that a complete rewrite is arguably a better option.

100X developers are the groups who turn impossibles into possibles. Some Uber engineers used to believe that Graphite was the best thing in the world and Nagios was second bar none, and they went ahead design a complex yet failing architecture for monitoring even when Uber's traffic was still tiny before Uber's M3 came along. This is what Netflix did with four engineers years before Uber's saga: https://www.quora.com/Are-Netflix-employees-really-that-good...

To those who couldn't scale out Graphite and got crushed under gruesome oncall alarms, the Netflix folks were 100x engineers.

100x in this sense is akin to doctoral level research. Think SpaceX turning the impossible into the possible with reusable rockets. Their returns on investment are now 100x greater than their competitors.

Graphite has been obsolete for 5+ years. There are commercial products with unlimited scaling, great UI, alerting and a hundreds things out of the box (see datadog and competitors).

That's not the point here. OP said, that the Netflix team could at the time deliver scale, while other teams couldn't.

Yeah, and the key difference is simple: The 100x engineers in Netflix just understood that file-based lookup for key-value pairs won't scale for OLAP-like workload on time series, and of course they possessed the sheer capability of implementing the right technology from ground up.

I was on Roy's team at this time. I am not one of the four mentioned in the link, but I definitely know exactly who is being talked about. I wanted to comment that these four were considered outliers even by Netflix standards for being very high performing. So bear in mind the example is an extreme one.

The Graphite story happened more than 6 years ago, or so I heard as I joined after M3 was in production.

Exactly this comment.

10x developers exist. 100x developers exist. These developers don't program 10x as fast or have 1/100th of the code. They bring 10x or 100x more value as compared to other developers.

People in HN seem to forget: Code doesn't live in a vacuum. Code has purpose. Code fixes problems. 100x developers are the ones that bring true value. That value may come from a 300 LOC data structure that improves efficiency by 50% or a 30-page code architecture that improves scalability. The means to produce value are irrelevant. What matters is how much value you bring to the table.

Yeah it's not so much cranking out 100X the code as it is good decisions, good teamwork, and management that clears the road rather than throws up obstacles. Some people could not do the same, even given the same advantages, but at the same time it's pretty much impossible to produce the same kind of results in an environment without those. (Source: was on this team, but not one of the original 4)

Reed is taking that into account. Reed and Netflix have been creating software for many years. They certainly have had "Rockstars" who could bust out functional but unmaintainable code. Those people are not valuable to Netflix because Netflix is looking for long term success.

A 100x engineer exists in the context of a global company like Netflix. Because if a developer makes something just 1% better that translates into millions of dollars of savings or increased revenue because on the margins just 0.001% increase of new subscribers is thousands of customers.

> Because if a developer makes something just 1% better that translates into millions of dollars of savings or increased revenue because on the margins just 0.001% increase of new subscribers is thousands of customers.

Generally, the idea of an Nx programmer is comparing programmers on their output, not their outcomes.

Otherwise you go from trying to compare levels of skill to levels of luck.

Yeah, you can do terrible programming work on an extremely popular product, or do good programming work on a product that nobody wants or cares about. And no one is 100% correct about what customers want 100% of the time.

Netflix doesn't win or lose customers based on programmer performance, they win by having content that people actually want to watch. I don't care if the UI is 10% less slick, as long as they have stuff I want to watch.

The only reason I've ever considered dropping Netflix is "why am I paying for this when there is nothing I want to watch". Fortunately, they have come through with some interesting content recently, and I'm still paying them. But give it a month or two with nothing I want to watch, and I'm pulling that plug, and no amount of 100x programmers will be able to keep me as a customer.

Ditto. I do wonder what 100x developers get them. I don't know if Amazon Prime or Disney+ have 100x developers, but their streaming experience is similar to Netflix. Maybe Netflix is 5-10% faster. I can't say.

The point is, with a service like Netflix, it's absolutely the content that matters. People happily watch pirated cam copies of movies because they want the content so much.

Then again, the salaries of 10x developers are a lot lower than 10x creators (directors, showrunners, actors, etc)

> I don't care if the UI is 10% less slick, as long as they have stuff I want to watch.

It's not a coincidence that they happen to have stuff that you want to watch. You're aware Netflix also applies data insights to decide what to make?

>You're aware Netflix also applies data insights to decide what to make?

Of course I give something thumbs up or down depending on if I liked it - why would you assume I don't know what they do with that?

But they've still made some barely watchable crap, too, in spite of themselves, so I do have to question if rating things even matters.

The thumbs up/down is just one signal among many. They know in aggregate what people watch, how much of a movie/episode they watched, the kinds of devices they watched on, how much binging/pausing they did, when and where they watched it...

> they've still made some barely watchable crap, too

To you. That crap was undoubtedly entertaining to someone. Not to mention a 100% hit rate is nearly impossible in the creative biz.

https://old.reddit.com/r/scifi/comments/cj4rrp/was_another_l...

Netflix's "Another Life" was so bad that people wonder if it was made bad on purpose. It was absolutely awful, and anyone that thinks it was good loses any credibility about what's good or bad sci-fi.

And I've been developing webpages for many decades, and even worked quite a long time at a precursor to what Netflix is today - yes, an online movie streaming service. So please don't talk down to me like I don't know what any of this is about. You're seriously wasting your time explaining any of that to me.

I didn't intend to "talk down" to you, sorry if it came off that way. I just didn't agree with your original statement that programmers' performance has little/nothing to do with why people use Netflix. I still think you're completely wrong about that.

> I've been developing webpages for many decades

It can't have been that many decades, the WWW has only existed for 3 decades.[1] Even I've written at least one webpage in every single one of those decades. :-P

1. https://en.wikipedia.org/wiki/World_Wide_Web#History

"When I look for a streaming video service, I want to make sure their programmers are the best. The content isn't as important as the user interface or the algorithms that tell me what to watch."

Do you realize how absurd that sounds? Content is King. If Netflix had crap content, it wouldn't matter how good their programmers are, because the content would still be crap. I can tell you from experience that if Netflix ever folded, their contracts with studios would be worth 100x more than whatever code they developed is worth.

> I've been developing webpages for many decades

>>It can't have been that many decades,

The "WWW" was created in August 1991, and I was on it in 1992, so yeah, practically 3 decades. I was wishing for Javascript in a web browser years before it ever existed, back when I was using lynx to browse the web. And I was coding long before that. Yeah, I'm old. I've been around. I don't need you explaining anything to me.

> Content is King. If Netflix had crap content, it wouldn't matter how good their programmers are

I don't think I ever once said "content doesn't matter". If they only had dynamite content and a shitty user experience people would simply pirate the content and not pay for it.

> Yeah, I'm old. I've been around. I don't need you explaining anything to me.

I try every day to not become like that.

>If they only had dynamite content and a shitty user experience people would simply pirate the content and not pay for it.

Most people have no clue how to pirate anything. Out of 100 people in your life, including all your relatives, honestly, how many of them are willing and capable of pirating content? If you think it's over 25% you will have me ROFLOL. And all of those people will be just fine with a less flashy UI than Netflix has to watch content they want to watch. I mean, they've been using cable boxes for years and those absolutely SUCK for finding content - but they still watched, because there is content they want to watch, or not, so they don't watch.

You're really making some very weak arguments.

> If you think it's over 25% you will have me ROFLOL.

Laugh it up then: https://www.theverge.com/2019/4/17/18412159/game-of-thrones-...

Even if you're right, you're admitting a good UX gets at least 25% of the people to pay money instead of pirating.

That link doesn't support anything you're arguing about. Why continue this when you're just flailing around making ridiculous claims. People like you are why I left reddit.

Netflix programmers can help you find what you want to watch. All the content in the world won't help them if you spend your time staring at the home screen while bad algorithms recommend the wrong things.

Not true at all, because in spite of all their content, and being able to find it, they still don't have anything new that I want to watch. I've already seen everything I wanted to watch. Now I debate leaving them because there is no new content. And after all "Content is King".

https://www.forbes.com/sites/steveolenski/2017/06/21/why-con...

>All the content in the world won't help them if you spend your time staring at the home screen while bad algorithms recommend the wrong things.

Their algorithms only optimize for the least profitable use case. It doesn't matter what the algorithm wants to suggest if they don't have the content I want to watch, or I've already watched anything worth watching.

Know what their algorithm suggests to me now? Sci-fi in foreign languages that I'm just not interested in because of its low production value and bad writing. But it's all they have left to suggest to me. That and everything I've already watched.

"Content is King".

> All the content in the world won't help them if you spend your time staring at the home screen while bad algorithms recommend the wrong things.

What? I can read about quality shows to watch on any number of websites or recommendations from people I know, and just search for the title of the show.

On the other hand, if you fill up your inventory with 99% garbage, like Netflix has, it doesn’t matter how good your algorithm is, since it’s going to come back with garbage.

I don’t notice any performance difference between HBO Max, Apple TV+, Netflix, or Amazon Prime. I press play, and it plays. What I do notice is most of the content is garbage, so I just wait to hear about good shows, and then once a sufficient number of people claim it’s worth watching, I go and play specifically that.

I'm perpetually frustrated with nf's UI, and tend to rag on them a bit. But then, my partner got subscriptions to other services. Disney, crave, amazon, showtime... holy shit is it actually difficult to remember what I've watched and take me to the next episode? I'll still crab about nf, but the competition is hot garbage.

I wish everyone would just license and retheme Kodi or Plex and be done with it.

Just in case: Netflix is 15% of the Internet traffic world-wide and about 1/3 of the traffic in the US (these figures can be a bit obsolete). So the engineering challenges I'd imagine are not so much about UI and recommendation engine as it is about pushing bytes efficiently.

Latter should be serious problem but Netflix improves both.

>A 100x engineer exists in the context of a global company like Netflix. Because if a developer makes something just 1% better that translates into millions of dollars of savings or increased revenue because on the margins just 0.001% increase of new subscribers is thousands of customers.

This dumb developer multiplier has really taken on a whole bunch of different convenient meanings.

The original idea had absolutely nothing to do with company success. It's not even useful now and it was questionable before.

The guys doing money printing machine control software must be 100'000x engineers.

The starts at Netflix are the procurement people that ensnare good movies while drinking fine wine on Manhattan or whatever. I would not say it is an engineering company like say, IBM or Oracle.

I think people often underestimate how bad the average programmer is out there.

It’s apparently not unheard of to have C programmers who don’t know function pointers or even structs work, or who don’t know what a build system is (only ever used an IDE).

There are many people who will just plug stuff together until it works somehow, without understanding why or how it works in the end.

Indeed, have a little trip to the outsourcing world, where you're paying for a team of experienced developers, some of whom have never developed anything before.

That's the antithesis of HN of course. Most commenters here probably work for tech companies.

It is depressing that people are happy to just throw anecdotal evidence around without even defining what metric they multiply by 10x or 100x.

There is some literature on it. For example, this blog post [0] contains some references.

I have only read Peopleware. It says 10x is the difference from worst to best in terms of time and number of defects across a few hundred programmers. Also interesting: Within the same organization, there was only a difference of 30%. This means the environment is much more important than the skill, experience, or personality of a programmer.

I cannot find any studies after 2000. Most of the data is even older. The Peopleware data is from Cobol, Fortran, Pascal, and C.

[0] https://www.construx.com/blog/productivity-variations-among-...

If 100x is from 100x the throughput of a 0.1x developer, in reality some developers are <0 net contribution. If I'm a 10x and the baseline/worst is -5x, then I need to start saying I'm a -50x developer.

Better than expected

> in reality some developers are <0 net contribution

Yes, sadly this is honestly true. Especially if you take into account the time spent to manage them, and then cleaning up after them, a person can easily be negative net contribution.

Honestly that's one of the ways I feel I've made a hiring mistake. It's okay to invest more time than it would take me to do a task to teach someone else to do a task, knowing that they can learn and improve, and eventually that investment of time will pay off. Eventually they should be teaching me things too, and doing things without needing any help. But if someone is constantly taking more time, and it doesn't look like that investment is getting paid off, I get nervous.

Then when the team starts slowing down, management will become even more resistant to getting rid of people, because you need to "go faster" which in their minds is simply some matter of headcount.

I feel like this can actually happen in practice... Your code sucks and then you hire a 10x developer who is really good a duct taping everything in your code to work with nasty hacks. Good times!

I have one friend and he programs at least ten times as fast as I do (in typing). I can barely keep it up with reading.

And in my CS class I was in the top quarter percentile, he was in the top 1%. The difference is big. They type code as fast as I'm typing this comment, while having a sane architecture.

The secret: they programmed a lot more as a kid.

I think the sane architecture is the only relevant part.

Real world "10x" developers are almost always in that class because they can solve the same problem with 1/10th the code of a 1x developer.

Ability to solve problems with less code will always outpace faster typing.

To be clear, you don’t mean code golf levels of code-shortening, right? E.g. they’re also not sacrificing on clarity and readability of code to shorten it. They’re just removing unnecessary work. I think this is definitely good and creates a net gain for other devs.

Because the people who shorten code at the cost of clarity are some of my least favorite people. I once saw “half = num >> 1” instead of, say, “half = floor(num / 2)”. The latter is 100% more clear to more people and doesn’t gate-keep on engineers who haven’t memorized bitwise operators. (Also, this wasn’t a context where the bitwise operator would be optimized by the compiler in case they wanted to throw that hogwash out there.)

Code golfing is mostly a exercise in asininity.

But personally, short, standard, and sweet is preferable to crazy newfangled mental model. I've seen way too many real-world examples of the idiom "it takes a lot of skill to write Java in every language."

In the good old days

half = num >> 1

Was standard practice and understandable by most engineers, as well as far and away much faster than a divide.

Now-a-days, using a compiled language they are going to be translated into the same machine code supporting your point. However, it might still be a good idea in a scripting language doing heavy math lifting.

I think the accepted standard for "code length" is about the number of tokens used, not the number of characters (or at least should be). So no points for replacing readable identifiers with random punctuation or one character variable names. And comments don't count towards the length either! :)

> I once saw “half = num >> 1” instead of, say, “half = floor(num / 2)”.

Again, that's just stuff that's getting you a small constant factor less code, a few characters here and there. To get closer to an order of magnitude smaller program solving the same problem requires a deeper understanding of the problem and different strategies for solving it.

To me, the gold standard example for the 10x to 100x coder is always Peter Norvig.

https://norvig.com/spell-correct.html https://norvig.com/sudoku.html

Notice the clear comments and detailed explanations and reasonable identifier names. But do you think the median developer would solve these problems with a similar amount of actual code?

Amount of code doesnt matter, what matters is the design decisions that are made

Design decisions can easily allow you to implement the same functionality in an order of magnitude less code.

Also, research shows the number of bugs per line of code is pretty much constant across programming languages and kinds of programs. So reducing the number of lines of code will almost certainly reduce the number of bugs, statistically speaking.

I very much believe in 100x developers related to the .2 or -.5 x developer. These people have the potential to accomplish little or even slow everyone else down by focusing on the wrong things, and writing difficult to maintain code.

In that sense a 1x developer is infinitely more efficient than someone who is a net loss to the team and 100x is nothing.

I do agree that it would be very difficult to be 100x better than someone who has decent technical skills and generally displays common sense and stays focused on useful paths.

> Good developers are the ones that create code that resists the slide from a 10x code-base to a 0.1x code-base.

10x is 100 times bigger than 0.1x FWIW.

> but I argue that it is at least partly due to the prevailing code-base.

Its almost exclusively because of the prevailing code-base. We can't forget that the prevailing code base was built by developers of varying skills. You can have "100x" developers build it or you can have "0.1x" developers build it.

> One of my least favorite people to work with is also a "high throughput" developer who is a prolific creator of software, but everything created by this person is an un-maintainable, un-documented, un-tested, brittle block of procedural copy-pasta that ends up in the critical business path. And yes, this developer "snapped" about a year ago and it has been a 3 person project ever since to scramble to fix this stuff.

Was this person the aforementioned "Rick" from this article?

Obviously it wasn't "Rick" in the flesh (I think). But more a "Rick" class programmer. :) Sorry to anyone who's real name is Rick.

> Every competent developer is a 10x developer on a green field project just like every competent developer is a 0.1x developer on a messy legacy spaghetti-code disaster of a project (Making the differential 100x I guess).

Wow!!! so true, never heard it said like this.

I don't know if it's 100x or 10x, but I assume that's just a figure of speech and used for effect rather than stated as an objective quantity.

"The thing with "10x" developers, is often times they (or a group of them) can do things that the average developer can't. Take Netflix as an example, would they have even started on the whole cloud thing if they had average engineers? Or if they did, would they have been thought leaders in the space for so many years.

> Maybe a 100x developer is really just a 5x developer who enables 20 teammates to also be 5x developers?

Or just a developer that makes the lives of 2000 engineers a little bit easier.

> Good developers are the ones that create code that resists the slide from a 10x code-base to a 0.1x code-base

That may be true of good developers. On the other hand, in my experience "10x developers" are the ones causing the slide.

> 10x developers

If they're causing code quality slide, they're not a "10x developer."

"No true Scotsman"

A Scotsman will always be a Scotsman due to his ancestry or citizenship.

If a 10x developer does not deliver 10x productivity or value of the median developer, they do not meet the definition of a 10x developer.

Depends on the project. If you have to develop features just for ticking off points in a contract that nobody will ever use or prototyping it can be pretty useful. If that code will run 10+ years then not.

This feels like the ones often seen as 10x heroes, because they're the only ones who can be productive in the mess they created.

I think one misconception is the range. I think that the range is dependent on the situation both immediate and long term. The immediate situation’s range is more bounded. The bottom of the range can veer into the negative and the top can go way beyond 10x. It’s more a phase change at that point.

Example of >> 10x phase change: Jeff Dean and Sanjay Ghemawat with MapReduce and BigTable.

For the negative, I think we all have seen the programmer who is useless and that actually requires other people to replace their work.

I agree, but I used 0.1 - 10x for illustration purposes only.

Your best developers are your competitor's worst. It easier to destroy than to build!

It all depends on the problem space: if the deliverable is a program that produces a proof of Fermat’s last theorem then Andrew Wiles would have been a 1000000000000000x (or Inf) engineer on that project at a certain point in time...

Also, there are entirely different “10x engineers” being talked about as one and the same here. The copy-paste spaghetti guy probably couldn’t even get a job at Netflix...

Agree, my model isn't complete.

Unrelated to your point but I think a lot of people who write really bad code are the only choice because they are experts in another essential domain, and there aren't a whole lot of experts in both that domain and writing software. So you do what you can. There is a reason that code written by EE's is often derided as terrible.

Er, isn't it a bit of a strawman to suggest that people that talk about 100x engineers are talking about 100x productivity?

Nobody I've met thinks that there are a set of people that believe there are "developers that write code 100x faster than other developers" but when people write comments on HN they act like this is a really common belief and only they are able to spot that it's not sane...

Everybody that I've met considers technical prowess more along the lines of: the ability to write complicated code which others would find difficult to do, the ability to simplify a problem in order that it can be solved without complexity, the ability to optimize the performance of something in order that it uses less resources, the ability to come up with an innovative design that others wouldn't have thought of, the ability to explain technical ideas to their colleagues in a way that enables others to achieve more, the ability to balance short-term goals against a long-term plan, etc.