Why Speed is the Scourge of Empathy
The byte and the burden
I’ve spent the better part of two decades in this industry (infrastructure, product, support, and leadership), and if there is one constant across every startup ecosystem, it is the religious worship of Velocity.
We chase it in our metrics, we staff for it, and we write deployment pipelines (often using concepts like CI/CD) to make sure that nothing (absolutely nothing) impedes the flow of code from a developer’s branch to a user’s screen. We have automated away almost all friction in the machine, yet paradoxically, our teams are burning out faster than ever.
The infrastructure itself runs smoother, but the human infrastructure is failing.
It wasn’t always this way. When I started out, a deployment was an event. Not a routine pipeline commit, but a planned, high-stakes moment. We had time (and, frankly, systems that forced us to have time) to talk through changes. We understood failure deeply because the feedback loop wasn’t instant—it was often a late-night call after an unexpected server crash.
Think about the systems that once reigned supreme, like the massive VAX minicomputers. Though I never developed on these machines, I was a user during my early college career. Like every other user, I was affected by planned maintenance. For the team managing the systems I used, this bred a slowness that required planning, communication, and, most importantly, consideration for the users (and other engineers.) It required emotional intelligence.
The very definition of continuous integration (CI) is a technical optimization designed to reduce technical risk, but we mistook this technical velocity for human efficacy. We adopted DevOps practices (which are fantastic for systems) but forgot to apply the same rigor and thought to our people operations. We built systems for rapid failure and recovery (which is good), but we didn’t build a culture that allows humans to fail and recover without punishment (which is disastrous).
When a modern system using CI/CD auto-merges a feature, the technical debt is flagged in seconds. But when a team member feels rushed, overlooked, or unheard (a product of the pressure to maintain “velocity”), that human debt often sits silent for months, eroding trust and psychological safety until the entire project implodes.
The irony is that sustainable velocity (the kind that scales for two decades, not just two quarters) is a function of high emotional intelligence, not low friction.
Empathy is the most critical piece of infrastructure we need to be building right now. It is the real-time monitoring system for your team’s collective morale. It is the automated rollback function for bad communication. It is the 32-bit (or more) virtual address space we need to understand the memory limits (cognitive load) of the people we rely on.
We must slow down long enough to see our colleagues not as cogs in a DevOps pipeline, but as complex, analog systems (prone to bugs, yes, but also capable of genius) that require care, non-judgmental failure states, and ample processing time. The future of work isn’t about more automation, it’s about more deliberate human interaction.
The history of computing is fascinating, particularly the machines and systems that defined the early days of corporate IT: