Communication is the core of software development. We shape our solutions through conversations with customers, stakeholders and colleagues. We evolve architecture through debate and discussions. We write code to talk to other devs and our future selves.

Back in the days, these important conversations were mostly limited to the Analysis Phase. The discussions and debates that mattered happened at the beginning of the project. From there on, it was merely execution and slight adaptations. With the rise of more feedback-driven methods and what later became the “agile software development” movement, that norm has shifted. Having those conversations is the software developer’s job throughout the entire lifecycle of the product.

Developers used to read specs and turn them into products. These days the average developer spends as much time in workshops and whiteboard sessions as behind a keyboard.

Better communication leads to better software.

But here’s what stands out to me: most of this communication is synchronous and unprepared. We join meetings without agendas. We come up with solutions on the spot without much deep thought. We start pair programming and try to figure out the problem as we go along.

What’s missing in modern-day development is deliberate and focused thought. Thinking before we speak.

Let’s take a whiteboard session for example. We’re presented with a problem, have 2 hours and go straight into solutioning. If we’re honest, most participants are not prepared. They haven’t read up on the problem. They didn’t investigate a few ideas up front. We just use the time slot to come up with a solution on the spot. More often than not, it’s only the loudest opinion in the room that prevails. Wouldn’t it be better if the participants investigated the problem on their own? Came up with a few well-thought-out arguments and a checklist of caveats before joining that whiteboard session?

Some people will instantly grasp the problem, others need more time. Most topics are too complicated to discuss without basic knowledge. People are never in sync when it comes to learning: we study as individuals, not as a group. So why not let people take some more time for thought?

To be clear, I’m not saying there is no value in whiteboard sessions or mob programming. What I am saying is: there is tremendous value in studying up and getting a basic picture of the problem before discussing potential solutions.

A written essay instead of blurting out a caching strategy at a whiteboard. Quietly digesting a proposal on your own instead of waiting for your turn to speak.

I’m not claiming all synchronous communication is bad. Far from it. But it shouldn’t be the only way we discuss topics. Written, async proposals where the author takes the time to formulate their ideas are powerful yet overlooked tools.

Software development would be better off with a little less talking and a little more thinking.