Laziness can be dangerous to a company; people with this trait can slow down an entire organization by procrastinating too much and lead the whole team to lower productivity and higher friction. This holds true in most cases, however, when mixed with other traits, controlled laziness can lead to incredible results.
I have been building software since I entered college and I have known many developers since then. I've worked with most of them as well, and one thing that I've discovered is that talent and knowledge is not enough to build the best software. My discovery has led me to believe that laziness can be very useful under certain conditions.
Let me explain. Software engineering is about telling computers what to do through code; whereas, laziness is a disinclination to do work and a desire to do the least effort possible. So, as a first thought, a lazy software developer is someone that wants to avoid doing too much work and write the least code possible to achieve what he's been commissioned. Nevertheless, software is very different from other industries, the most elegant solutions are lightweight (the amount of code isn't representative of the quality of said code) and efficiency is critical to achieve great results.
Now, imagine we have two developers, John and Peter; both of them are lazy devs. John chose engineering because it is well-paid. Whenever a new project comes over, he will do everything he can to do the least work possible, he will procrastinate as much as he can and maybe copy-paste some code he found on the Internet to "get the job done". Meanwhile, Peter loves his job and wants to write some quality code for this project, with the lowest effort possible in the long run. He will go over his existing code and find that most of it is outdated or needs further improvement; an idea goes through his mind, "this code could fail in the future and if the product crashes I will have to repair it. I don't want to do that. Could I just write common code for all of my projects and avoid work later on?". His laziness will drive him to avoid any future work, so he will build a framework or library that will allow him to write better code faster with less effort. His laziness has transformed into efficiency.
In the long run, John's code will become buggy, messy and difficult to maintain; while Peter's will be always getting better, leading to leaner products and more robust software systems. And, as you may know, the best software is always the less buggy, the fastest, the most efficient, the most scalable. It may not apply to other industries, but simplicity is the cornerstone of engineering. So, what makes Peter different from John? Three traits:
- Passion: John is not interested in making things better, his main motivation is a paycheck, that won't be affected by the quality of his work or the effects of it on the long run (at least that's what he thinks). A developer passionate about software isn't satisfied with "I'm finished", he wants to deliver something he's proud of. Peter will try to achieve this, but through the fastest route available. Now, this can be double-edged sword, faster development can be good sometimes, but it can also lead to lower opportunities for innovation and sloppy aesthetics.
- Long-term vision: This is a trait that most people should have. To see beyond the immediate future; to extrapolate and imagine the impact of our actions in the long-run. When I was first introduced to the concept of technical debt (Shout-out to @justavo for that one), it changed the way I perceived software architecture. Developers need to stop being code monkeys "building" software that will eventually tumble and crash. Bad code will only get worse with time.
- Self-improvement: Nobody will get far by thinking no one can best them, neither will the quality of their work. Developers have to be humble enough to know they work in a fast-paced industry in which whenever you become an expert on something, you come to be out of touch with the newer trends and technologies. Breaking the wall between college-educated and self-taught is very difficult, but once you master it; there's no limit to what you can do. A good developer has to be eager to find the best way to achieve an objective, but also, be lazy enough to find the answer as efficiently as possible. I have seen passionate developers spend hours browsing for an answer, researching every article and piece of code; build a criteria that will allow you to find answers that help you bootstrap faster without over-analyzing each and every one.
So, where does this bring us? The best developers are lazy enough to avoid reworking, doing patches and resolving bug issues; however, they derive willpower from their passion for software development in order to overcome their laziness and become even more productive. This is the kind of developer that will try to automate everything to avoid doing any more work, for example, if you ask him to do transcribe a bunch of written pages to a digital document, he will very likely build a tool based on speech-to-text or a scanner to avoid this "menial" task. This is the true spirit of engineering, making our lives easier through innovation and technology. In some way, you could say that our laziness is the basis of civilization. E.g. we were too lazy to use the stairs so we invented escalators. Same thing here, some developers were to lazy to write the same code over and over, and patching every single project every time, so they invented code libraries.