Claudio Lassala's Blog

Let’s say we review some test code:

// Arrange

var customerInvoice = CustomerInvoice...

Someone suggests refactoring. Their version looked like this:

given_customer_invoice();

Same test. Different language. And that small shift makes me think about how we talk to each other as developers.

We All Have Accents

Most developers speak with a thick technical accent.

React developers have their own dialect. So do Angular developers. C# developers who started when the language was born and never learned its functional features still speak C# with an object-oriented accent. They don’t quite understand how LINQ works.

Put two experienced developers in a room—one who lives in React, the other in Angular. If they each speak only in their tool of choice, they might not have a productive conversation.

But what if they both spoke basic English? What if what they read on the screen resembled the language they actually speak?

I believe they’d be on the same page more quickly, understanding the problem they’re solving instead of debating syntax and patterns.

“Does that word mean the same to you as it does to me?” would be a question in the context of a business domain, not in the context of programming languages and their intricacies.

When the Accent Gets Too Thick

I once saw a developer-turned-project-manager write user stories using pseudo code:

If customer exists

  Show the data

Else

  Ask if the user wants to create it

    If confirmed

      …

    else

      …

That’s not even about the technical accent anymore. It’s about defaulting to programming constructs to solve any problem.

I don’t believe that “user story” serves its purpose. A user story should be a placeholder for conversation, describing the value of a feature for someone who’ll benefit from it. This reads like an implementation plan.

The Language We Speak Shapes How We Think

If a Texan spends a year living in London, she’ll likely come back speaking with a different accent and using different words.

The same thing happens to developers. Spend enough time talking technical, and you end up thinking technical and speaking technical. Even other developers can’t always relate to the talk. It builds a wall between technical and non-technical people.

I’ve heard developers described as “extroverted amongst their peers, introverted amongst business stakeholders.” I believe that’s because they mostly think and communicate in technical terms, and have a hard time outside of that comfort zone.

Code Is Communication

Developers who have a hard time communicating—verbally or in writing—also struggle to communicate through code.

Some people struggle with verbal communication but do well in writing. But doing badly in writing certainly compromises understanding of their code. If English sentences are hard to understand, code will be too.

There’s a quote from On Writing Well that sticks with me:

“To write better than everybody else, you have to want to write better than everybody else. You must take an obsessive pride in the smallest details of your craft.”

Maybe developers should read that book. Not just to write better documentation, but to write better code. Where does that fit in the Age of AI, when the tools are writing most of the code? AI Starts at the Average — You Take It From There.

There’s another quote I connect to these thoughts:

You can improve your communication skills with practice much more effectively than you can improve your intelligence with practice. If you’re not that smart but can communicate ideas clearly, you have a great advantage over everybody who can’t communicate clearly.

What I’m Noticing

The tools we use shape the way we think. The frameworks we learn create dialects. The patterns we adopt become our accent.

And sometimes, that accent gets so thick that we forget we’re trying to solve human problems.

I’m not saying we should avoid technical language entirely. But I notice how often we reach for it first, even when plain language would serve us better.

What if we practiced translating our technical thoughts into everyday language? Not dumbing it down, but making it clearer. More human.

Would our code become clearer, too?