The Speed Tax

Every security breach I've watched unfold in the last eighteen months has had the same shape. A feature shipped fast. A review that was cursory, or skipped. A vulnerability sitting in production longer than it should have because the team was already three sprints ahead. The speed was real. So was the breach.

We have convinced ourselves that fastest is better. Agentic coding tools have made this belief practically irresistible. You describe what you want, and something builds it. The loop that used to take weeks takes hours. Entire product surfaces get shipped over a weekend. This feels like pure upside. It has a hidden cost.

There is a hidden cost to moving at this speed. I'm calling it the Speed Tax: the compounding debt you accumulate when you remove the deliberation that used to be built into the pace of building.

Here's the mechanism. Slow software development had a feature that nobody named while it was happening. When implementation was expensive, people thought harder before they started. A product meeting that dragged across three weeks wasn't just bureaucratic waste (it definitely can be but hoping to strike some nuance here) – it was time during which someone in the room would eventually say, "what happens when a user does this?" or "who owns this if it breaks?" Those questions got asked because the alternative was a multi-week project nobody wanted to unwind. Friction created accountability by making decisions feel real with real costs.

Agentic tools removed that gravity. The decision to build something now costs almost nothing. And when decisions cost nothing, people make more of them, faster, with less scrutiny. Companies in pursuit of product-market fit were already bad at this. The hustle-porn culture that dominated the last decade celebrated shipping as a virtue and deliberation as cowardice. Agentic tools handed that culture a supercharger to all the wrong people.

The Speed Tax shows up in three places.

It shows up in security. Code that gets generated faster than it gets reviewed is code with unknown behavior. An agent scanning for vulnerabilities is doing something categorically different from a senior engineer who knows the threat model and the data classification and the history of what changed two years ago and why. We removed the slow part of the review process and called it efficiency.

It shows up in product quality. When every idea can be implemented cheaply, teams stop asking which ideas deserve implementation. The backlog becomes infinite. The product becomes unfocused. Every feature is a vote for complexity, and complexity is a debt that collects interest in maintenance costs, on boarding friction, and edge cases nobody anticipated.

It shows up in culture. There's almost no value in stopping to think about consequences when your colleagues are shipping features by the hour. The social reward in an agentic-first environment goes to the person who built something, not the person who asked whether it should be built. That's a values system, and it tends to produce organizations full of people who build fast and learn slowly.

It shows up in who ships. The junior engineer using an agentic tool doesn't know what she doesn't know. He/She's never debugged a race condition at scale, never watched an auth edge case quietly corrupt a user table, never lived through the Monday morning when the rollback failed. The senior engineer who used to slow things down wasn't just being cautious. She was transferring ten years of scar tissue in every review comment, every architectural objection, every "have you thought about what happens when." Agentic tools don't transfer scar tissue. They just ship.

Amazon recently re-added human gatekeepers to their code deployment pipeline. (They had removed them in an aggressive push toward agentic-first workflows, watched what happened, and quietly reversed course.) They didn't announce it as a retreat. They called it a process improvement. It was an admission that some of the friction they'd removed was structural, not bureaucratic. There is the nuance.

Our worst impulses are now fully funded. I wont even dive into how this is compounded with rooms of engineers who don't want to do needed maintenance work and management who doesn't see or understand why its valuable.

The tools themselves are not reckless. Many teams use them responsibly, and some agentic workflows produce more careful output than their manual equivalents. The problem isn't the technology. The problem is that technology doesn't impose the judgment that slowness used to force on us by default.

So stop treating deliberation as a tax. Start treating it as the product. The review meeting where someone asks the uncomfortable question, the sprint planning session where the team argues about scope, the architectural discussion that takes three days – these are not overhead. These are the places where the Speed Tax gets paid before it compounds.

The tools will keep getting faster. Your judgment doesn't have to scale with your velocity.