Over the years, I have observed that, as an industry, we have valued precise code creation over complex planning in software.
I shared a joke recently that seems to resonate with anyone who has sat through a design review:
“I love how a one-hour meeting to review your architecture spec is viewed as a waste of time and unnecessary, but spending 6 months to rework the system is considered a great use of time.”
As a human being whose precise code creation is poor, but is very good at planning (literally, I did a neuro-psych eval that says that), this has been a painful struggle. The thing that takes visible time is the code creation. What takes invisible time is planning. We have historically treated the “invisible” as non-existent.
The folks doing the code creation often resent the planners because, to be quite frank, we are not in the trenches. In command-and-control hierarchies, those who are very good at planning are often viewed as undesirable distractions from execution. I’ve written before about how this “execution-at-all-costs” mentality leads to the unbounded step—the manual, expensive human intervention required when a system wasn’t planned to handle failure states correctly.
Over the years, I have had people attack me in private and public because they see planning as divorced from execution and thus dangerous. In fact, if I look back at my career, I find it amusing that I was stuck at an MTS3 and almost laid off, and then, because the team needed planning, I got promoted to TD at NetApp in four years. I didn’t even notice this until someone snarkily remarked, “Well, apparently the annual Kostadis Promotion didn’t happen.” I didn’t improve; what happened was that what I did was finally seen as valuable.
The thing is, I do believe that to do good planning, you have to understand code creation and its limits. A planner who can’t do that isn’t a good planner. I recently demonstrated this when I had to bridge the gap between workflow and code to fix a personal cloud-sync issue; I knew the logic, even if I used agents to handle the syntax.
The role of the software architect has been viewed with contempt because, too often, architects are divorced from the system’s capabilities. But the industry is pivoting. Planning code is now far more valuable than creating precise code. Good planning, combined with AI code generation, produces significantly better code than bad planning does. As I’ve codified in my Agentic Architecturalist prompt, the “Architectural Conscience” is now the primary bottleneck.
A senior tech lead I spoke with observed that the engineers who could plan outperformed those who could not by a factor of 10 in quality. Because every line of code is reviewed by a human, good planning is imperative. Otherwise, we are burning a lot of human cycles on “maybe” states and technical debt.
The world has most definitely changed.
Leave a Reply