
The Myth of the Myth of the 10x Programmer - payne92
https://payne.org/blog/the-myth-of-the-myth-of-the-10x-programmer/
======
remmargorp64
10X programmers DO exist. They aren't just a myth, and they aren't just about
knowing when to buy vs build, or when to use a particular framework or
toolkit, or how to "mentor" other developers.

Chris Sawyer wrote 99% of the code for RollerCoaster Tycoon in x86 assembly
language, with the remaining one percent written in C.

RollerCoaster Tycoon was a beautiful game which still stands the test of time
to this day. The fact that a single person was able to build a blockbuster-
level game almost entirely by themselves _in assembly_ is a truly impressive
feat which very few programmers would even dream of undertaking.

Being a "real" 10X programmer is like being a savant. It's about being FUCKING
SMART, and it's about being able to deliver a working, polished product in the
same time that a normal team of ten people would be able to deliver it (or in
a tenth of the time that a single person might).

~~~
Nition
Not to diminish the achievement, but worth noting I think that RollerCoaster
Tycoon was based on his earlier Transport Tycoon engine, so at least he did
get to split the work up between two projects.

I have a personal theory the that the average 10x programmer is say 2.5x
smarter than average, but also 4x more focused on work, netting a 2.5x4=10x
total when you remove all the procrastination and general fumbling around of
the average developer.

~~~
JackFr
> worth noting I think that RollerCoaster Tycoon was based on his earlier
> Transport Tycoon engine,

The 10x productivity comes in large part from the code they DON'T write.

~~~
jacquesm
And from writing things the right way the first time around rather than on
iteration #3 or so.

------
jimbokun
Here is your 10x programmer:

[https://norvig.com/sudoku.html](https://norvig.com/sudoku.html)

"In this essay I tackle the problem of solving every Sudoku puzzle. It turns
out to be quite easy (about one page of code for the main idea and two pages
for embellishments) using two ideas: constraint propagation and search."

If you gave this task to an "average" developer, how long would it take for
them to implement? How many lines of code would it be? Would the
implementation be correct? How long would their code take to execute?

    
    
        % python sudo.py
        All tests pass.
        Solved 50 of 50 easy puzzles (avg 0.01 secs (86 Hz), max 0.03 secs).
        Solved 95 of 95 hard puzzles (avg 0.04 secs (24 Hz), max 0.18 secs).
        Solved 11 of 11 hardest puzzles (avg 0.01 secs (71 Hz), max 0.02 secs).
        Solved 99 of 99 random puzzles (avg 0.01 secs (85 Hz), max 0.02 secs).
    

Does the average developer know what "constraint propagation" and "search"
mean in the above sense, or remember enough about them from their CS class to
recognize them as the right tools and how to implement them?

Also, can the average developer implement a spell checker from scratch on a
single transcontinental flight?

[https://norvig.com/spell-correct.html](https://norvig.com/spell-correct.html)

So Norvig is always the paradigmatic example of the 10x developer, for me.
Having a broad range of CS techniques at your disposal and knowing how and
when to deploy them, is almost a super power.

~~~
mjw1007
I'm sure Norvig is very good, but I think the sudoku webpage is presenting a
finished program in an idealised way, not recording the process he used to
write it, false starts and all.

(It seems likely to me that there were some false starts, because eliminate()
returns either `values` or False, when both of its callers would be just as
happy if it returned True or False.)

~~~
jimbokun
He didn't give an implementation time for the sudoku solver, but he did say he
completed the spell checker in a single transcontinental flight.

~~~
WalterBright
I don't remember how long it took me to do the spell checker challenge:

[https://github.com/dlang/dmd/blob/master/src/dmd/root/spelle...](https://github.com/dlang/dmd/blob/master/src/dmd/root/speller.d)

but I'm sure it was much longer than it took Peter. This checker is used by
the D compiler to look for a misspelled identifier when a symbol lookup fails.
The identifiers in scope form the dictionary.

It works surprisingly well. I added it to the Digital Mars C++ compiler as
well.

[https://github.com/DigitalMars/Compiler/blob/master/dm/src/d...](https://github.com/DigitalMars/Compiler/blob/master/dm/src/dmc/dspeller.d)

------
amznthrowaway5
> highly productive developers (10x or otherwise) are problem-solving at a
> much higher level

This is a very important point, but calling these highly productive developers
"10x" doesn't really make sense. They are more like "infinity times" compared
to the average when it comes to getting a difficult task done, since the
average developer would just get stuck and never be able to invent good
designs and solve the difficult problems. Even worse, some programmers are in
the negative on many tasks, adding additional complexity and overhead while
making little to no positive contributions, especially when you give them a
problem beyond their capabilities.

~~~
wpasc
Joel Spolsky's "Hitting the high notes" always comes to mind for me when this
debate arises.

~~~
goatinaboat
Spolsky is a 10x blogger. Neither he nor any of his employees were ever 10x
programmers. There was nothing algorithmically clever about FogBugz or
CityDesk or whatever.

~~~
lolc
Did you miss how they cross-compiled Vbscript to PHP? I'd say for a lot of
programmers this would have been quite the challenge, algorithmically
speaking. And I would classify it as clever. With both the positive and
negative connotations of the word.

------
marcus_holmes
I think part of the objection to 10x programmers is around expectations, self-
assessment, and attitudes.

There are people out there who have difficulty working with others. Some of
those people feel that this difficulty is because they're so FUCKING SMART and
the others are morons who are beneath them. They're extremely difficult to
work with in a team environment, but come across as completely confident about
their own abilities.

These people are toxic to work with. They drag everyone else in the team down
(part of the reason they are productive is that everyone else has to spend
time and effort dealing with their bullshit).

Management should spot this and deal with it. But in a lot of situations the
"10x" has managed to get into a position where they have a lot of information
that the rest of the team doesn't have (deliberately, usually) and getting rid
of them would be difficult. And some managers buy into the whole myth as well,
and having a toxic "10x" on their team that they have to carefully manage is a
point of pride, or something.

This archetype, the lone genius developer who is 10x everyone else, is
extremely appealing to some people. Regardless of their actual ability, they
start believing that they are this. And worse, behaving like this.

So while, yes, there are some programmers out there who are very productive,
the majority of self-proclaimed "10x programmers" you're actually likely to
meet are just socially unaware assholes with inflated egos.

~~~
leroman
Being a consultant for a considerable part of my career, whilst sometimes
working solo on writing a system from scratch.

In one example, re-writing a system written by 7 team members + architect,
taking half the time.. Maybe due to working in an organization without a
formal org position.. I had to make sure bad requirements, process, tech
decisions etc.. don't get in the way of properly collecting requirements,
designing and building this system, seen today as a hugely successful project
for this company. I have to say, some people see me as an asshole, no doubt,
other's see me as a bulldozer that got the work done and stand behind me and
keep in touch to this day.

Our interaction will depend heavily on if you are in my way or not, though I
don't consider my self toxic or hoarder of information.

~~~
marcus_holmes
I'm glad this appears to give you some satisfaction, but I hope I never have
to work with you, or around you, or on any project you've worked on.

~~~
username90
What is wrong with ignoring and working around toxic people who only
undermines the project?

~~~
leroman
Ignoring sounds passive but there is nothing passive about telling people
their ideas and cooperation is unproductive (be it people from product, RnD,
management, QA etc), you spend much time and energy convincing them their
ideas are not concrete, or are going in a bad direction, or are simply bad..
Having the burden of completing the project (successfully!) on me, I have to
cut through the BS and provide results, not attend to egos and fragility of
everyone involved.. Never the less, I try to be dry and not personal as I can
to communicate the situation as simple as possible to the other party.. In my
consulting career I learned that being "nice" is not worth it and ends up
costing me in mental health..

------
hardwaregeek
Y'know, productivity is kind of overrated. The programmers who I admire aren't
the people who could implement a React CMS in record time, but the people who
built React. Or Rust, or Haskell, or FFmpeg. I guess one could argue that the
programmers are 10x, 100x or even (10^n)x simply because their work has helped
other programmers become more effective, thus through the multiplier effect
resulting in massive productivity. Or because you need someone who can work at
10x to build something of large impact. But first, that just means that Large
Impact => 10x, not that 10x => Large Impact. Second, that's oversimplifying a
massive, nuanced impact into a number for no real reason.

Honestly I suspect the idea of 10x developers was created as a way to explain
to managers why you need to pay ol' Leslie over there the big bucks. If you
claim Leslie works at 10x the speed and only needs 2x the salary, the math
works out for a business major. So I guess that's the reason you need the
number.

~~~
terminaljunkid
> If you claim Leslie works at 10x the speed and only needs 2x the salary, the
> math works out for a business major. So I guess that's the reason you need
> the number.

I think that's perfectly justified. So much is lost in software quality
because those people think programming as dry labour and outsource to cheap
sources, losing so much in future revenues but unfortunately that's not even
measurable.

Joel Spolsky put it nicely in a post: It is not that it requires `n` bad
programmers to do what one good programmer does. It is that `n` bad
programmers can't build what a good programmer builds, no matter how big `n`
is or how much time it takes.

------
gilbetron
The concept of the 10x programmer seems to have been drifted from its original
meaning. It isn't that there's a coder that is 10x better than a _good_ coder.
It is that a lot of people are really bad at their jobs, and a coder that
thinks and learns about problems can be far better than those people. It comes
from terrible "corporate drone" software developers in the 80s and 90s - the
ones that would takes weeks to developer simple routines. Bring in someone
that loves software dev, and they appear magical.

Today, with Google and Stack Overflow, that gap has diminished, but there is
definitely people still way better than "average" developers. However, if you
have someone that keeps their skills sharp and their problem solving desire
sharper, you won't fine anyone 10x - maybe 2 or 3x, at best.

~~~
headmelted
Agreed.

I've never encountered someone that I think is genuinely a 10x programmer.
I've worked with a few people that thought I was one, which I'm most certainly
not, and I've explained that to them.

I've encountered a lot of what I would call .2x programmers though. As you've
said, there are a lot of people that are really bad at the job. It's not a
slight either - there are a lot of people doing this job that really don't
care for it at all.

It's hard to be good at a job you don't enjoy. Especially if life forces you
to do it 40+ hours per week.

~~~
saagarjha
> I've never encountered someone that I think is genuinely a 10x programmer.

I have. (Interestingly, some of these people knew this and had a surprising
lack of modesty about it as well…) Usually I think it boils down to being able
to have the experience to consistently guess right on things, come up with new
ideas, and not get tangled in the weeds: most of them are smart, but not so
smart that you’re just lost when talking to them.

~~~
m0zg
>> not so smart that you’re just lost when talking to them

That, BTW, is a sure sign that someone is trying to appear smarter than they
really are. Having worked at 2 research labs over the course of my career I
know more than my fair share of genius-level people. Without fail, they are
humble about it, and can explain complex concepts in a way the rest of us can
understand. This is something that just blows my mind pretty consistently
actually, and IMO it is a sign of true, deep understanding of a complex
subject. The person didn't just memorize formulas (although many of them excel
at that as well), they understand why things are the way they are, the real
meaning behind it all.

It could be that this is selection bias though, and I only got to know
geniuses who aren't also assholes.

~~~
prostheticvamp
As Feynman said: you don’t really understand a subject until you can explain
it to your grandfather.

~~~
1337shadow
And that's how I explained the cloud to my grandma: the company buys big daddy
servers which make baby computers that the company sells for profit. She was
so happy she finally understood what my job was at the time.

~~~
afarrell
When I read this gestation/birth analogy, it makes it seem to me like a large
piece of hardware assembles and ejects a small piece of hardware. I assume in-
person there was more detail or different imagery?

------
WalterBright
I personally know many programmers who are easily 10x average programmers. No
question about it.

They crank out code that is easy to read, easy to understand, works right out
of the box, and gives years of trouble-free operation.

Sean Parent is one of those programmers. It's pretty obvious when he describes
how he replaced a nightmarish tangle of code that re-invented a simple rotate
algorithm.

It's a remarkable talk:

[https://www.youtube.com/watch?v=W2tWOdzgXHA](https://www.youtube.com/watch?v=W2tWOdzgXHA)

------
nybblesio
The OP's example is perfect: he didn't go to the leaf-nodes and write _each
test by hand_. Instead, it was clear that writing a tool to do the job would
be better. Software is all about leverage. This is what defines a 10x
programmer.

However, I'm constantly amazed how many programmers fail to see the forest for
the trees.

To a large extent, not seeing (or seeing and ignoring) this type of solution
is learned behavior. Many environments are hostile to this world view. Writing
tools (especially those that generate code...eek!) is seen as "over-
engineering" and "unnecessary complexity". If you're in a factory, on a line,
your job isn't to climb away from your leaf-node.

Any programmer has the potential to be 10x, they just have to see and act upon
it. Few do.

~~~
skybrian
It seems like you're almost debating yourself here, making arguments for
opposite sides. If anyone could do it and environmental effects make all the
difference, why emphasize individual initiative?

But maybe the best thing to do would be to find a better environment, if you
can?

------
CognitiveLens
It's worth pointing out that the research found a 10x _spread_ between the
least-productive and most-productive engineers - a '10xer' isn't someone who
does ten times more than the average, so it becomes less mythical if you think
about someone who does, e.g. 2x more than average in an organization with a
few burned out engineers doing 20% of the average.

~~~
odyssey7
Ah, so the secret to having a bunch of 5x engineers is to not burn them out.

------
BXLE_1-1-BitIs1
I remember one programmer that I characterised with "He writes a lot of code".
I ended up with one of his not small routines that I replaced with a one page
assembler routine in MVS NIP rather than OPEN.

When reworking printing software to support multi color, I researched a
commonly used subroutine though several layers of calls and replaced it with,
yes, a single character constant.

I lost count of the many legacy applications where I tossed out great gobs of
code produced by "productive" programmers.

~~~
RealityVoid
I do not think 10x means "churns out code" but rather "produces results". And
by this metric, by golly, there are a couple 10x out there for sure.

~~~
prostheticvamp
I think OP here was asserting that he was 10x in comparison to that guy, as
being much more efficient.

------
petilon
10x programmers do exist. But here's the thing: its not worth being a 10x
programmer. Managers don't necessarily want them.

First of all, if you complete a project 10x faster than the expected time,
managers will assume that they had overestimated the project, as opposed to
recognizing that you're a 10x programmer. I have seen this time after time
after time.

Secondly, if a manager does recognize that you're a 10x programmer then you
will be seen as a risk: what happens if you leave the company? If the product
was built by a team then that's a legit business. If the product was built by
just 1 person then that's not a legit business as the business can suddenly
collapse if that 1 person leaves.

Third, you make your co-workers look bad by raising the expectations bar. You
will not win any popularity contests. You may make your manager look bad too,
if your performance diminishes the value of the manager.

If you're indeed a highly capable programmer here's my advice: don't be a 10x
programmer by doing 10x the quantity of work or completing projects in 1/10th
the time. Instead be a 1.1x programmer, then expend your remaining energy
helping your teammates grow, and broadening your influence. (So scale yourself
horizontally instead of vertically.) This advice is often not easy to heed if
you're introverted, and if you're extroverted you are already a manager
instead of a programmer.

~~~
pepper_sauce
The modern workplace for an employee is really not designed to incentivize
above average productivity. I don't claim to be an anything-X developer but I
find my productivity runs in cycles. In the circumstances I've turned out high
value work in a matter of hours or days, I've literally been told by
colleagues to slow down because I was making them look bad, while management
assume that's just how long the task takes. At the other end of the spectrum
when I'm (relatively) under-performing nobody cares: that's just how long a
task takes, and nobody feels threatened.

The damping effect is real.

------
e1g
I think we instinctively recognize the outsized levels of certain pros: a 10x
leader that is a different creature from a typical manager, or a captivating
writer that is 10x better than the average novelist, or a 10x actor vs a
standard-issue LA newcomer, or a 10x teacher who inspires far beyond what
curriculum mandates. Can we accept 10x lawyers, coaches, artists, or musicians
based on their impact? We do, and we seek and celebrate them. Why fashion
designers but not app designers, why essay writers but not program writers?

------
Eridrus
One thing I have observed recently is the existence of "10X projects".

This might be a symptom of working at a big company, but I have been really
impressed by the ability of some projects to achieve their ends while others
get stuck in quagmires due to the fault of nobody on the project per se, but
rather the definition of the project itself.

------
1e-9
Harder problem => Increased productivity variance

For extremely hard problems, it's not difficult to measure greater than 10X
differences between highly-talented senior developers and the average
productivity of those capable of meeting requirements.

------
dustinmoris
This whole 10x programmers debate is tiring. Why do we even argue over such a
dumb thing? OF COURSE THEY EXIST. That is not even debatable. It's a fact of
life that there are people who can achieve more than others. It is the case in
sports, in politics, in school, and not surprisingly also in tech.

You have football players who play their entire life and they don't progress
beyond a hobby team and then you've got the likes of Christiano Ronaldo and
Lionel Messi.

The question is does it give a 10x dev a justification to behave like a dig?
No, it doesn't. You still have to be a good team player, just like in a
football team a 10x player won't perform well if he/she is pissing off the
rest of the team.

So can we stop debabting about facts of life and just get on with it?

~~~
lazarljubenovic
I never understood the concept of 10x apart from it being a (misused) meme.
For (almost) every developer you can find one that will do "the thing" a few
times faster and one that will do it a few times slower. It also depends on
what is "the thing".

~~~
anthonypasq
This is another example of this delusion people have about specificity when
comparing outliers to normal people.

Genius level programmers are better than you at everything related to computer
science. And if they aren't familiar with it, they will become familiar with
it in a fraction of the time and then easily surpass you. This is why we call
human intelligence 'general'. Because it applies everywhere.

Unless you think your ability to do your job is entirely dependent on tooling
and learned knowledge, smarter people will quickly become better than you.

------
ccheever
I think the way to think about this is that there are some people who figure
out ways to do things or invent things that just wouldn't be figured out or
discovered by other people.

So, it's not 10x or anything-X even, it's just that, if the stuff that can be
uniquely provided by "10x" people is important to you, then you need someone
like that. 10 1x developers aren't likely to give you that (except to the
extent that you have 10 chances to discover that one of them is actually a
10xer on some dimension).

------
bloody-crow
I think team sports is a good analogy here. There's no people who are 10x
stronger, or who can run 10x faster than their teammates, but there's
certainly people who'd score 10x points in certain circumstances than anybody
else, and that is what 10x programmer is about.

~~~
james_s_tayler
Team sports is a terrible analogy. Like someone else mentioned, software is
about leverage. There is no leverage in team sports.

------
mikekchar
The reality of the situation is that rather than 10x programmers, there are
actually 0.1x programmers. Frequently you will have teams that are so burdened
by whatever hurdles are in their way that they produce only a tenth of what
they could be producing. Interestingly, there are programmers who self impose
those hurdles. There are programmers to impose those hurdles on others as
well. Quite frequently, though, the hurdles are either imposed from afar, or
occur as a result of unfortunate decision making that has accumulated over a
number of years.

A real "10x" programmer is a programmer who is able to unshackled themselves
from the burdens that turn them into 0.1x programmers. Beware, however,
because many of these people achieve their productivity at the expense of
others on the team. Indeed, there is a special breed of programmer who will
inflict 0.1x burdens on the rest of the team precisely so that they can appear
to be a 10x programmer.

I once worked on a team of 5000 programmers, where the average number of lines
of code produced per programmer per day was 1. We can all argue that KLOC per
month is a terrible productivity measure. However when your productivity is
around 20 LOC per month (without the K), there is something _seriously_ wrong
;-) 0.01x programmers (at best)????

~~~
ClumsyPilot
Are we talking about a case where a given developer has re-written 100 lines
of code, and added 1 line net?

Or do you mean that only 1 line was written or re-written? If so, what are
people doing, having 7-hour meetings?

~~~
mikekchar
No. We had 31 million lines of code and it was so complex that even changing 1
line had massive implications. Definitely the worst code base I've ever worked
on. I originally started working there as a contractor because they had single
functions which had reached the file size limits for their build system and
they didn't know what to do (you know... maybe split this function up into
smaller functions... maybe...). There were people who were unrolling loops
because they were unaware that the compiler would do it for them under the
hood. And then somebody would modify one part of that loop, so you'd be
looking for some strange behaviour and it would be buried in the middle of
some code that was copy and pasted 100 times. Total nightmare. Don't even get
me started on how they did their memory allocation.

~~~
sibeliuss
Very curious to know what you were working on! 31 million lines of code?

~~~
mikekchar
It was a telephone switch (Now defunct Bell Norther Research)

~~~
sibeliuss
The scale of this is too vast to even conceive....

------
t0astbread
It doesn't matter whether 10x programmers exist. Programming is not a sport
and as such, competition will only lead to narrow thinking, useless
optimization and hatred. What we should really strive for is making
programming a more creative activity where people learn from and inspire each
other, not a competition.

Oh and also, "finding the 10x engineer" feels like a hotspot to inject hidden
bias into recruiting.

~~~
closeparen
Communication overhead is expensive. All else being equal, it’s much better to
build a small elite team that can operate successfully with less structure and
process, rather than a large average one.

~~~
t0astbread
Right. But you can't build a functioning team that works together and can rely
on each other by fostering a culture of competition and hiring only the
"predestined" 10x engineers.

If the team culture is to help each other, forgive mistakes and learn from
each other without measuring who's the best the team will automatically build
itself without the need to hire only "10x engineers".

Or so I suppose. I'm not an HR person or anyone else with expertise in this
field so you should take what I say with a grain of salt. I've just been
thinking about this a lot as of late.

~~~
closeparen
Where I’ve seen teams with high concentrations of unusually smart people, they
gelled and collaborated at least as well as anyone else. In fact the bandwidth
and fidelity of their idea transfers is part of what made them impressive.
It’s like they had their own little language to describe the codebase and what
to do with it.

These were mature and soft-spoken people; might be different with brash young
hotshots.

~~~
t0astbread
To me that sounds like an environment where there's not a lot of competition
involved. (Which is what I was describing.)

~~~
closeparen
They were far and away the most selective team in the company.

I’ve seen this before in university too; competitive to get into can still be
cooperative once in.

~~~
t0astbread
HN thread limit might cut this off but what if someone in that team starts
experiencing problems and self-doubt? If everything in the team has always
worked smoothly before they might not be able to handle it.

Additionally, elitist teams might scare off some people that could otherwise
be great engineers if they just got a little entry help. Sure they can "get
that elsewhere" but if every team behaved like that there's not only nowhere
to enter, but there's also sort of an omnipresent assumption that you have to
be good from the start in order to be able to achieve something in
engineering.

I'm not saying your described team doesn't work but it's not exactly the kind
of culture HR should be striving for in my opinion. (Albeit it's still far
better than than a team that doesn't work at all or works against each other.)

------
koonsolo
I've been a 10x developer compared to my yesterday self.

I needed to add a feature that required a big rewrite of my framework. This
would take maybe 2 weeks.

The next day I realized I could support that exact same user benefit with only
a few lines of code.

Sometimes just looking at the problem differently, or sleeping over it can
have a huge impact, not only compared to other developers, but also to
yourself.

------
yodsanklai
> I think 10x developers, like world-class athletes, musicians, and authors,
> absolutely do exist.

For this question to make sense, one should give a better definition of what
constitutes the output of a programmer.

In a sense, there are Nx programmers for any arbitrary N because some
developers can build things that other can't.

But we can't reduce the work of a software engineer to "programming". Most
"programmers" today aren't developing some new hobby systems from scratch
(it's the easy part IMHO). They work in the context of a team, they have to
deal with legacy code (possibly boring, using technologies they don't like),
they write doc, review code, discuss designs and solutions, they give talks to
present their work, they train or supervise colleagues, they interact with
difficult managers or colleagues and so on...

In that context, I wonder how "star programmers" operate. I wouldn't be
surprised if some of them are even under-performers.

------
thoman23
A few people have touched on it here, but I'll add my voice. I firmly believe
that there are programmers who are better described as a "1 vs. 0" programmer.
Some programmers have a creative talent in them that leads them to create
elegant solutions that literally a team of 50 average programmers would not.

------
gandalfgeek
If you look at the original paper (going back to 1968) where the data for a
10x difference was first found, there are a ton of... issues.

I've covered this in detail here:
[https://www.youtube.com/watch?v=Gho89X72Xas](https://www.youtube.com/watch?v=Gho89X72Xas)

------
oarabbus_
There are 10x salespeople, 10x authors, 10x basketball players, and 10x
scientists; why should there not be 10x programmers?

------
overgard
I agree with the article, but I also think it leaves out something fairly
important, which is minimizing huge time sinks. Instead of being 10x better,
how can you reduce wasted time 10x?

I remember working with this one guy that was light years smarter than me, but
if you watched him use the IDE it was _painful_. He did _everything_ in the
menus, slowly. How much of his life could he have back from memorizing f5 and
a couple other shortcuts?

Maybe you could reduce waste in various ways:

* Learn keyboard shortcuts instead of pecking through menus

* Use search instead of browsing (especially with keyboard shortcuts!)

* Have you ever lost half a day debugging something that turned out to be dumb? (I have!) Is there a way to modify your coding style or your testing habits so you never hit that again?

* Do you know your stack well enough that (given the time) you could reimplement the same ideas yourself? (Or is it a magic box that you can't debug? How much time and effort do you spend prodding the magic box?)

* Have you automated all the manual things you currently do?

* Are you wasting a lot of time dealing with bad abstractions when something much more basic would suffice?

* Are you mastering your tools/languages/frameworks, or are you switching around so often that you spend a lot of time looking things up?

* Do you have input into how your tasks are written, or are you stuck with whatever breakdown someone else came up with? Is your work getting awkwardly twisted to fit into these milestones? Can you work out a better system with your leads?

That's the tip of the ice berg -- I think if you look at almost anything you
do, you can generally find some aspect of it that's cumbersome and wasting
your time. I feel like when you account for wasted effort/time, and removing
it, becoming "10x" starts to seem a lot more reasonable -- it's not about
being a genius, it's about being introspective and careful about how you
perform your work. It saddens me to say this, but I think that sort of
introspection is rare. I see so many programmers doing uncomfortable awkward
things every day, because it's only like 10 extra seconds, except those 10
seconds times 20 times a day times a year and now that cost is out of control

~~~
wvenable
If you think 10x programmers are merely more efficient and writing code,
you're wrong. A 10x programmer produces 10x less code to solve the problem
which is why they're 10x faster at it and the quality if higher.

Some of this advice is good but actually being _speedy_ is not necessary.

------
slowhand09
They are rare, but definitely out there. I've worked with one, managed one,
never been one. One charateristic I observed over these 2, they'd take a
manual home and read it over a day or two. They'd retain most of it. They tend
to be touch typist not needing to look at the keyboard often. This reduces
context switching and lets them flow when they are being creative. They know
and remember syntax, library routines and interfaces so they aren't stopping
to look things up. They "try on the fly", fail fast and often, and move to
alternatives when blocked. The ones I know I'd love to start a company with.
But I would be the bottleneck...

------
NohatCoder
I don't know if there is truly such a thing as a 10x programmer, but I have no
doubt that 0.1x programmers exist in hordes. Even people who at small scale
seem competent can often end up making a complicated mess when dealing with
bigger projects.

------
kunglao
Considering how software development has become relatively lucrative and so
many want to throw themselves at this, it's bound to create a large pool of
incompetent engineers. Specially because this isn't an industry that is
regulated like medical doctors or architects. Given that, I think it should be
relatively easy to find 10x performers on different teams.

However, to find a 10x guy in a high-performing team, that'd be a sight :)

------
keanzu
If we take a simple application of Price's law:

The square root of the number of people in a domain do 50% of the work.

In a group of 121 the top 11 are doing 10x the work of the other 110.

------
helsinkiandrew
The best way to carry 8 gallons of milk across a muddy field in a leather bag
is to leave it in the cow.

I never assumed that the 10x programmer was actually writing 10x the amount of
code in the same time but instead knowing how to do something in a 10th of the
time, with less risk and cost (by a using a better algorithm, novel approach,
or 3rd party package etc).

It's the difference between being a developer and a programmer

------
SideburnsOfDoom
> I developed them in 3 days, by writing a C program to automatically generate
> the range of tests.

So they were 10X at that task. Are they like that, consistently, all the time?
Maybe next time it's another person's turn to have the insight on how to
drastically simplify the task.

This is not "10x people" at all then. This is a "10x day" or a "10x week" in a
fairly normal person.

------
nhumrich
I find that I am a 10x developer when I compare myself to other versions of
myself. I have had days where I honestly feel bad because I got almost nothing
done, and other days where I get a ton done. If I was able to correctly
channel my focus and effort, I would be 10x then I used to be. Now sure, maybe
the time spent not as focused allows me to have those bursts of productivity.

------
chx
I'd argue today a team could be 10x. Yes it requires someone who knows the
concepts and can effectively communicate them but also awesome project
managers, designers and QA personnel. A great team (I am lucky to be part of
one) functions like a well oiled machine churning out acceptably quality
features and fixes the problems at a surprising rate.

------
sunstone
To make an analogy with the ancient Roman trieme ships with three tiers of
rowers. A 10x rower in that context is not the guy who can pull the oar 10
times harder, it's the guy who, while he can pull the oar, can also tell you
when the ship is on course because he knows how to navigate and thereby makes
everyone's effort more efficient.

------
DantesKite
Despite the differences in definition, reading the comments on this page has
been lovely. I’ve enjoyed the many perspectives.

------
noicebrewery
The author of this article is a 10x self-promoter for using a hotly debated
precept to humblebrag about his accomplishments.

------
liamcardenas
Why wouldn’t there be such thing as a 10x programmer? Is the average
programmer so good? There are outliers in every industry. Professional
athletes are a clear example — they are often many orders of magnitude better
than the average player of their respective sport.

There are probably also a few 100x engineers, maybe someone like Elon.

~~~
paublyrne
The equivalent comparison would be professional athletes at the top of their
sport to other professional athletes in that sport working or playing in a
lower league. Would the the top performers be 10x the other ones? Hard to
quantify this, but I'd say no, more like 2x or at most 3x

~~~
thoman23
All you have to do is look at someone like LeBron. He single-handedly makes a
team a championship contender.

------
whateveracct
If you're really 10x and you're giving that 10x to some company and not
getting 10x value, you're doing yourself a disservice! Either get fair value
(probably won't happen) or give them less than that 10x and use your spare
energy for other pursuits (relaxing, entrepreneurship, art, hobbies, etc)

------
d--b
He’s saying 10x developers are those won’t don’t code 10 times faster the same
code, but those who find ways to code 10x less for the same results. that I
agree with.

But then he compares 10x developers to world class athletes... That’s a bad
comparison. The 10x developer is the guy who takes the bus instead of running
marathon!

------
cmhnn
How does an industry so full of brilliant people who consider themselves much
smarter than their users keep arguing in these absolutes about programmers
like their skills are easily classified.

Many things have become popular that were originally written like ass by
someone who was better at making something people found useful than they were
at data structures or thinking in big O.

A lot of genius language design people are nearly useless when the whole messy
world of shit like network, filesystems and interacting with things not their
language is involved.

Programmers being human also are not some consistent machines that constantly
maintain some level of productivity regardless of what is going on in their
personal life or their interests waxing or waning in a given problem space.

The people whose code has changed the world are maybe a handful or two. So,
astounding developers much better than most do exist. But even they are not
some multiple of every coder for every problem.

Nevermind, it's time to stop even thinking about programmers alleging truisms
about programming and go get my MSNBC|FOX fix so I can get the necessary
stimulus to knee jerk.

------
DonHopkins
It's not that Alan Turing was a 10x or 100x programmer (not that there were
many others to compare him to at the time), but that he had a deep intuitive
understanding of mathematics, which he could apply to many problems from
different fields.

------
xornor
It is very easy to find -10x programmers, which proves that there are also 10x
programmers. It depends on the reference skill level.

------
paulus_magnus2
Can we stop the self hate already? There definitely are 10x musicians, 10x
painters, sportsmen and 10x programmers. You know what never exists in 10x
form? Burocrats and middle managers who write articles like this one.

I suggest to flag this as fake news and all future articles intended to
devalue young talented programmers who yet are to discover their true market
value.

~~~
michaelbuckbee
Not trying to be a jerk, but I think you might need to re-read the article as
the author is clearly a developer themselves and thinks that there are
definitely 10x developers (just that they can't be found with a simple coding
test).

~~~
Bnshsysjab
I would like to think I’m one of them, I’d flail about in attempt to solve
some random programmer test, but I’m also the guy that sits back and says ‘hey
how about we rethink this i n s a n e architecture?’

------
tanseydavid
10X programmers do exist but good luck finding them as Job Seekers.

It is also a concept which is NOT SCALABLE.

------
xtf
Problem is the scale. Script kiddies and junior programmers are 0.1x to 0.6x
or people reinventing the wheel by not using a framework, they could be far
less and let's not talk about security. Experienced (senior) devs should be
counted as 1x. Beside knowing to programming fast, they (should) know how
programm more correctly.

------
loopz
What have the company done in the past 15 years to build a progressive
learning culture?

------
bsaul
If you look at it the other way, is there any field where some pro aren’t 10x
« better » than other pros, at least by some metrics ?

In sport it’s pretty obvious there are, and you can measure it because there’s
a « winner » and a « looser » at the end of each game. But i’d imagine it’s
there in pretty much anything.

------
jpswade
Being a 10x programmer is not sustainable and doesn’t scale well.

A great team is not made up of lone rangers and wild stallions.

------
wanone
10x programmer @ 1x pay

------
lincpa
If you use [The Pure Function Pipeline Data Flow v3.0 with Warehouse/Workshop
Model]([https://github.com/linpengcheng/PurefunctionPipelineDataflow](https://github.com/linpengcheng/PurefunctionPipelineDataflow)),
although the development speed will be a little slower, thinking will be a
little more, but later reading, incremental development and maintenance will
be less than ten times.

------
ten_xer
As a 10x programmer myself (NOT TO BRAG) I will tell you we definitely exist.
My greatest annoyance is watching the rest of you peons crawl along at a
snails pace while I am inventing the next groundbreaking technology that will
completely flip your existence upside down. Perhaps the only person who could
even understand my level of motivation is Elon Musk, but I'm not even sure if
I would have the patience to explain it to him.

It is a daily occurrence that while you are trying to find a missing semicolon
that I'm already cleverly arranging your old commits using git rebase to turn
your finger-painting into a Van Gogh. My only advice is just to get used to
it, because we aren't going away. The best thing you can do is hope to get a
management role so that you can be freed from the burden of competing with us.
Let's be frank: most of us 10x programmers are on the deep end of the spectrum
and therefore won't want or perform well in a management role, but for those
of us that can, managing normal programmers would be excruciating.

~~~
slowhand09
This guy is so 10X his/her user didn't exist before this response. And he's
been 10X and productive talking about it!

