I am quite possibly the laziest programmer you know. At least, I think so; I can't be bothered to check.
Several years ago, at a different job, my boss walked by my office and asked me "why don't I hear you typing?" At the time, fresh from college and not wanting to rock the boat, I immediately started typing out some C# code I'd been thinking about. This lasted only as long as it took for him to leave, whereupon I stopped banging out these BS "solutions" and started thinking and Googling and generally determining what way was best to solve this problem, rather than blindly charging ahead.
I was fired a few weeks later, mostly because I refused to work overtime, but partially because I just "wasn't doing enough work." I later found out they thought of me as "lazy" because I didn't type very much.
I couldn't help but think, "what's wrong with lazy?" Now, several years and a better job later, I am convinced that laziness is one of the principle defining characteristics of a good programmer.
Lazy Is Good
Lazy programmers are good programmers. They don't do more work than absolutely necessary.
Lazy programmers will not deal with problems more than once. Consequently, they often think through potential issues thoroughly so that they won't have to solve it a second time. That quick, off-the-cuff solution that they can bang out in an hour? Lazy programmers will realize that it will come back around to give them more work in the future, and they are not gonna stand by and let more work happen to them. Anything which causes them work is a problem that needs to be dealt with, correctly, the first time it arises.
Lazy programmers abhor redundancy. They go out of their way to reduce the amount of code they write, because they know that the more code that exists, the more likely it is to cause them future work. In fact, in their opinion the best code is no code at all, because it cannot break.
Lazy programmers explain their decisions. They write thorough comments, expand on existing documentation, and generally try to ensure that they are being clear, because God help them they are going to explain this one time and one time ONLY!
Lazy programmers automate everything that can possibly be automated, even the coffee pot. If there's work to be done, and it needs to be done regularly, it can and will be automated.
Lazy programmers teach people more junior than them, partially so those junior people can do the work instead. They spend time and energy now to show what the proper way to do things is, so that the juniors can do it that way or better and stop bothering the lazy programmers.
Lazy programmers expect to be replaced. They know that obsolescence is coming, and they accept this fate because, hey, that means less work for them. They even help it along; they write the tools that will make their own job obsolete. Lazy programmers know that if you can't be replaced, you can't be promoted.
In short, lazy programmers want to do as little work as possible right now. But they also want to do as little future work as possible, and so they ensure that the work they do is as efficient, concise, easy to comprehend, and replaceable as possible.
What's wrong with that?
Be lazy. It's OK. Don't do the work more than once. Write the docs so you don't have to write them again. Explain yourself clearly and concisely the first time. Teach people more junior than you so they can do the work. Think about things so you don't have to think about them again. Laziness has saved me more hours of fixing stupid things than I can possibly imagine. It takes practice, but everyone, yes EVERYONE, can do it and get good at it.
After all, if you can be lazy and still do a better job, why wouldn't you?