@theorangetheme @davidgerard
I’ve never really believed in the 10x developer, but I was quite fortunate that I spent a long time in software development before I encountered a very real phenomenon (surprisingly common in big tech companies): the -1x developer. The person who creates so many problems that it is an entire other person’s job to clean up the results of the mistakes that they make.
In some rare cases, you may even encounter a -2x or -3x (or more) developer: someone who writes code very quickly and leaves a trail of devastation. They will do things like start a large-scale refactor that doesn’t solve any real problems and introduces some major design flaws, get half way through it, and then use the fact that they are leading this major transition to get promoted and transferred to a different part of the company. The team left behind has to deal with either finishing the refactoring and ending up in a worse place, or undoing all of their work. Both approaches delay new features and the team looks much less productive while they deal with this fallout. And the sudden drop in perceived productivity after they leave is used as evidence for how great they were (‘oh, yes, when I was in that team we were shipping new features and I was leading a transition to pay down a load of technical debt. As soon as I left, the whole thing fell apart. It’s a shame, but I had to move to a place where my skills could benefit the company more.’).
I can see LLMs allowing a -1x developer to easily become a -10x developer. And honestly believe that they are more productive because they never realised that their productivity was negative to start with. I would be entirely unsurprised to discover that industry is now littered with LLM-enabled -10x developers. Technical debt is too weak a term for their output. Companies are accumulating technical nuclear waste and it will be decades of work to fix all of the problems that they have caused.