The Passive Aggressive Art of Technical Leadership
Image TSD/ChatGPT
So much in the office annoys me. People loudly talking when you’re trying to focus on something. Shoes that make unnecessary noise on the plastic floor. Needing to come to the office to experience the whole ambiance.
So perhaps it’s our senior staff engineer’s way of coping that leads them to react to my shoddy code with a passive aggressive tinge. Each time we interact it begins with three simple words.
“If you have time…”
Is this some new management technique from X? Is this a way I’m being managed?
It’s probably indirect communication.
You have areas to improve (AKA you’re rubbish)
I’m hearing it more and more. Instead of saying that the code won’t work, or there is a production issue with my latest refactoring they say something else entirely.
You know the type of passive-aggressive way people use to control you and make you feel…worse than you already did.
By prefixing anything with “if you have time” to remove agency from the target developer immediately.
If you have time, you could improve that abstraction.
If you have time, we should probably add some more tests.
If you have time, maybe that service should be refactored.
If you have time, perhaps we should make this more reusable.
If you have time, maybe we should support another edge case.
It’s a lovely approach because everyone knows what it means, with complete plausible deniability.
It’s like my pregnant colleague who hasn’t yet made the announcement. Everyone can see it, nobody says anything and we carry on as before.
Fiction can be the best book to read on a long flight, can’t it?
The Root Cause?
I start to think that everybody knows…but no one’s saying nothing.
We can’t say that AI is making code quality worse, if we would like to keep our jobs that is. Now I’m not sure that our senior staff engineer is thinking this when he is passive-aggressively berating me for poor code yet:
The pressure to work at 10x is insufferable. We need to write code and solve problems like never before.
So as developers when we see code that looks plausible we wave it through the coding stage.
The first version works.
The demo passes.
The happy path behaves itself.
Whack it into production and the job is done. What more do we need to worry about?
If you’ve a stack of tickets stacked up which need to be completed by the end of the week, you might not ask yourself the obvious questions. Now it’s becoming the job of senior software engineers to roll out the following questions.
“Why doesn’t this handle retries?”
“What happens if the request arrives twice?”
“What happens when the API changes?”
“Why is this dependency here?”
Your reasonable pull request suddenly isn’t, as the commits balloon into double-digits.
If You Have Time Means You Don’t Have Time
The problem with “if you have time” is that software developers never have time.
Every sprint is full, the roadmap is ambitious and you should have delivered that PR yesterday
I have no idea how, but every deadline is always critical to the survival of the business.
“If you have time…”
Is nothing to do with your “capacity” or even capability. It’s about control.
What they are really saying is:
“This should be fixed, but I don’t want ownership of prioritizing it”
And for them it’s an elegant solution.
The senior developer gets to identify the issue, and it gets fixed (it might even be on their priority list). Management doesn’t need to allocate additional time, and the delivery date is met.
On the other hand the developer doing the work quietly inherits all the responsibility. They won’t get the plaudits, they won’t get the appreciation for doing the work,
Everybody wins except the person writing the code. Everybody wins except the person doing the work. Everybody wins except you.
The Missing Conversation
What I actually want from senior developers isn’t more observations. More problems to fix.
Finding problems is easy, and doesn’t even need a senior developer to do so. We all have Claude now, we all have ChatGPT.
Ask the static analysis tools. Ask the compiler. Ask the angry comments waiting in your pull request.
The difficult part is prioritization. Identifying which issue matters, which issue is real and which risk we need to mitigate is the real job. Knowing when to take a shortcut, that’s senior level work.
Being a good developer is more than pointing at problems. It’s about deciding which problems are worth solving at all.
If you take the locus of control away from developers who need to find their own problems (and solutions) you are taking away their opportunity to grow and to become a Better developer.
Conclusion
The next time a senior developer tells you:
“If you have time…”
Try asking a dangerous question.
“Which item would you drop from the sprint so I can do that?”
Watch how quickly “if you have time” turns into “maybe we can look at it later.”
Software development isn’t the art of making everything perfect.
It’s the art of deciding which imperfections you can afford to live with.
And according to my backlog, I can’t afford many.
About The Author
Professional Software Developer “The Secret Developer” can be found on Twitter @TheSDeveloper.
The Secret Developer has plenty of time available for improvements. Because, frankly. They do very little work overall.