This is a retelling of a story that I read for the first time many years ago. The last place I found a link to it was on a Quora blog, but that link is now dead, and I can’t find it anywhere else online, so I’m rewriting it as best I can here from memory.
Yes, I’m aware that it’s no longer considered cool to refer to “ninja” developers, but this story doesn’t make as much sense otherwise.
The Manager approaches three software developers with an important business task. “You must cross this field,” she says. “How long do you think this will take?”
Junior Developer looks out at the open field and says, “This looks easy! About two days should be good.”
Senior Developer, aware of the kinds of traps that may lay in such a field, responds, “Hmm, I see that there are a number of risks. Give me two weeks.”
Ninja Developer says, “I’ll be across in an hour.”
Then each start on the task. Junior Developer starts walking, but quickly hits a landmine which blows him backward. He stands up and walks forward again, only to be blown aside again and again. He eventually works his way to the far side, having taking a meandering course across the field with many setbacks, but it takes him more than a month to make it across, and he’s quite beat up by the process.
Senior Developer gets down on his knees and carefully checks for landmines as he goes, using tools to protect him from any hidden traps. He makes it across in just under 14 days, unharmed.
Ninja Developer simply walks straight across the field. She arrives on time in just less than an hour.
When The Manager asks Ninja Developer how she made it across the field so easily, Ninja Developer responds: “I didn’t lay any landmines.”
The difference between the junior and senior developer is experience. The junior makes lots of mistakes; the senior takes precautions against making those mistakes. The junior totally blasts past their estimate, and the senior is spot on. Both the junior and senior developers are attempting a problem that they don’t fully know how to solve.
The difference between both developers and the “Ninja” are that the Ninja developer can understand the entirety of the problem at once, and therefore can plan a straight path across without making even the tactical errors of the senior developer. The senior developer is protected from those tactical errors, and can quickly detect and work around them. But the Ninja can predict where they will be and create a design that won’t fall into those traps to begin with.
When you can see your destination, and you can understand all of the pitfalls between your starting location and your destination, you can just proceed from point A to point B. No need for the additional safety measures when you know where the problems will be.
For more of a concrete explanation of what form “landmines” might take, in searching for the original text (which I never found) I did come across this article talking about software landmines. And another article that I came across that mentions landmines and accurately describes the behavior of the junior developer above, calling it “programming by coincidence.”
The 10x Developer
Today the term “Ninja” developer is very maligned as a term; the latest term is probably “10x” developer, and some people don’t even believe that “10x” developers exist. At some level, though, there’s no “10x developer” as much as there’s a developer who is capable of coding at full speed on a particular task. Some tasks are harder than others.
A task that is simple enough, most experienced developers would be able to complete at roughly the same speed. A task that is harder will cause some developers to need to proceed cautiously, while others will still be able to “walk straight across the field.” And as task complexity increases, more and more developers will need to take care.
So there’s not a simple “Ninja” or “10x” developer cutoff; there’s just a spectrum of strength of developer, just as there’s a spectrum of skill and ability in just about every other human endeavor. And if a task is within the full skill of a developer, they’re the Ninja. If it’s not, they are the Junior or Senior developer, depending on their experience in that domain.