On Developers and Von Moltke’s Leadership Matrix

At my previous job, every Friday we’d have a team wide “code review”. While often times we reviewed code written by someone on the team, it was less a peer review session and more for discussion and learning. One of the more interesting ideas brought up by one of the developers was a leadership matrix such as this one:

Officer Productive Lazy
Smart Staff Officers Commanders
Stupid Avoid at all costs Useful for some purposes

Often attributed to Helmuth Von Moltke, the origins of this idea are clouded in mystery. Nevertheless, the matrix is a very interesting idea that makes some sense. And while I don’t presume to equate the art of app development with that of war, it certainly can apply very well.

So how does it apply? Well, first off, I’d replace the term “stupid” with “ignorant”. This is because all developers at some point are ignorant, whereas “stupid” means something different than what is necessarily intended. This works much more for the Lazy/Ignorant cell than the Productive/Ignorant, which oftentimes does tip over into the stupid realm.

I also gave some thought as to changing the term “lazy”, as it says something different to most Americans that what is intended. I don’t believe that it means those considered “lazy” are unwilling to put in necessary work or will not pay attention to their responsibilities. Rather, it means that they won’t just put their head down and keep at it just because it’s one way to get the job done. Rather, they’ll look for the easiest (and often fastest) way to get it done. By doing this, they show a keen flexibility for the situation at hand and can potentially keep costs and effort down while still getting the same result. All of that is kind of difficult to put on a table header, however, so for the sake of ease I’ll stick with “lazy”.

Therefore, this is the table as it applies to the world of programming and development:

Developer Productive Lazy
Smart Project Manager / Team Lead / Details Work Architect / Team Lead / Cleanup Hitters
Ignorant Avoid at all costs Bug Fixers / Flesh Out Code

The best type of developer is the Lazy and Smart developer. Not only will they be able to understand the bigger picture and know where things are going, they will also know the best way to get there. These are the developers you want building out your core modules, or solving the persistent Gordian Knots that every project encounters. They also can make great team leads, provided you don’t expect too much paperwork or bureaucracy from them.

Next up are the Smart Productive developers. They also can be great team leads, provided they have one or two Smart Lazy developers working for them who they can trust to get things done. More often they are the exact kind of person you need to handle managing a project, particularly the details and logistics that can so easily bog it down or send it completely off the rails. They also work great at handling the “detail” work the Smart Lazy developers are terrible at.

Following the Smart productive developers are the ignorant and lazy developers. Pretty much every developer will start out here (although some ignorant and productive developers will push forward into the Smart and Productive group). This is the standard definition of a junior developer. Some developers will graduate from this group within days; others will never leave this level. They are quite useful, provided they aren’t being required to make key decisions. The bulk of your usual bug fixes, and much of the coding can be handled by these developers, provided they have clear guidance, oversight, and examples from which to pull.

Finally, we come to Ignorant productive developers. While some of these developers can move up to be smart and productive, most will be stuck at this level. These are the developers you want to avoid at all costs. The problem with them isn’t that they will slack off at work. Instead, they’ll work very hard, but in the wrong direction. To them the process and the work is the most important thing, rather than where they are going with the work. This doesn’t mean they are bad people, and don’t have any talent that would be useful elsewhere. It just means that they are a guaranteed bad fit as developers.

So what’s the best balance for a team? It’s certainly not all Smart Lazy or all Smart Productive. A team full of smart lazy developers would get a lot accomplished with minimal effort, but would miss a lot of the important details along the way. Likewise, a team of nothing but smart productive developers would build a thoroughly documented and tested application that is over-engineered and took 90-hour weeks to accomplish. Thus, a mixture would make the most sense. There are many different mixtures that can work, but above all your best coder should be a Smart Lazy developer.

Share
Andrew

Andrew

I've been a programmer for almost 15 years, back in the rough early days of PHP 3. Am well versed in the world of PHP and MySQL. I have a deep appreciation of ZF2 and Doctrine. The thought of all the spaghetti code I've dug through (and written) keeps me up at night sometimes. My profile picture is not of me.
Andrew

Leave a Comment

Your email address will not be published.