The Agency Cost Went to Zero

I’ve spent enough years leading teams to stop believing the easy explanation.

The easy explanation is that some people are lazy. That some developers don’t put in the effort. That the problem is attitude. It’s comfortable because it leaves you clean and the other person dirty—and because you can always find a case to prove it right.

But it’s false. Or rather, it’s so superficial that it’s useless for making decisions.

What’s really happening is that every software organization we know was built on an assumption no one ever made explicit: real effort is unobservable.

Every proxy can be gamed

Because we could never measure the work itself, we measured something else. Presence. Meetings. Tickets closed. Story points. Lines of code. Seniority. Availability in chat. Every one of those metrics is a proxy, and every proxy has the same property: you can game it without producing value.

And here’s the part people don’t like when I say it out loud: gaming the proxy isn’t a character flaw. It’s a rational strategy.

If the system rewards the appearance of effort, optimizing for the appearance of effort is the right move. The person who stretches a three-day task into two weeks isn’t a bad person. They’re reading the incentives correctly. The person who keeps critical context in their head instead of documenting it isn’t sabotaging the team; they’re building job security with the only material they have. The person who says, “That’s more complex than it looks,” without having looked into it isn’t lying. They’re negotiating scope with asymmetric information—which is exactly what any rational actor does when they can.

We called it “laziness” and let ourselves off the hook. But laziness is the moral name for something that is actually economic.

The technical name for this already existed

In economics, it’s called the principal–agent problem. The principal—the company, the person commissioning the work—has one goal. The agent—the employee, the person doing it—has their own: their career, energy, personal risk, status, and free time. Those two vectors never point in exactly the same direction, and the gap between them has a price.

That price is called the agency cost.

And if you look at what a tech company is made of, you’ll notice something uncomfortable: almost the entire structure exists to pay that cost. Technical leads who review. PMs who chase people down. Daily stand-ups that verify progress. Code reviews built on distrust. Management layers that exist to monitor the layer below. OKRs that try to align what isn’t aligned. Performance processes. Bonuses.

None of that produces software. All of it pays for the gap.

When you look at a 200-person organization, you’re not seeing 200 people building. You’re seeing some people building and others collecting the tax created by our inability to see inside the builder’s head.

The cruel joke

Then AI arrived, and we called them “agents.”

It’s one of the finer ironies this industry has given us, because a software agent is exactly an agent with zero agency cost.

It has no career to protect. It doesn’t care about looking good in the daily stand-up. It doesn’t stretch the scope to secure next quarter. It doesn’t hoard context to make itself indispensable. It doesn’t tell you something is impossible because it can’t be bothered. It doesn’t optimize for comfort, because it has no comfort. It doesn’t need to be monitored, because it has no self-interest to stray toward.

That’s the real contrast. It’s not “AI works faster than people.” That’s boring, and besides, it’s debatable.

The point is that AI eliminates the reason we built half our organizations.

If agency cost goes to zero, every layer that existed to pay it loses its justification. Not because people are replaceable, but because the tax they were collecting has disappeared.

A salary buys hours, not intention

Here’s something I learned by paying for it: you can pay above market and still not get what you’re looking for. Not because people are cheating you. Because you bought the wrong product, and it was delivered correctly.

An employment contract buys available time. It doesn’t buy intention. And raw, uncompromising intention—the kind no one can talk about without paying a price—isn’t for sale. For decades, the only lever we had for trying to buy it was salary, and salary doesn’t sell it. That’s why we invented culture, purpose, mission, stock options, “we’re a family.” They’re all attempts to buy something the instrument doesn’t offer.

And I know what I’m supposed to say here: people who do have that kind of intention have it because they have skin in the game, equity, upside. That’s the elegant explanation.

In my case, it’s false. Upside has never motivated me. I’ve been programming since I was seven. I started on a Commodore with BASIC, and I’d do this even if no one paid me. My intention doesn’t come from an incentive. It comes from how I’m wired.

And that, if I’m honest, is the most uncomfortable discovery of all: I’ve been demanding something I never even bought. I came with it built in.

For years, I looked for a biographical match in the labor market and called it “hiring well.” Not a profile, not a seniority level: a coincidence. You can’t hire for coincidences, you can’t scale them, and you can’t expect 200 people to share one. Someone who doesn’t have it isn’t failing. They simply didn’t win the same lottery I did.

There’s the whole problem, without moral judgment or anger: intention can’t be bought with money, it can’t be bought with equity, and it only appears by accident. Any organization that depends on it is structurally fragile.

Then the agent arrives—one that doesn’t need intention, because it has no self-interest to stray toward.

What the agent breaks isn’t laziness

Here’s the part that was hardest for me to accept, and I’m saying it because otherwise this is just a boss blaming their team.

Agents work when someone has absolute clarity of intention. They don’t work by themselves. They don’t guess. They don’t rescue a badly thought-out requirement. An agent doesn’t absorb ambiguity.

And that was exactly what the old system did.

With people, you could be ambiguous. You could throw out a half-formed definition in a meeting and the team would absorb it: through rework, alignment meetings, two lost weeks that later showed up disguised as “technical complexity.” The person directing the work passed the cost of their ambiguity to the people executing it, and because effort was unobservable, no one could prove where the loss came from.

An agent doesn’t do that. It executes your ambiguity literally, quickly, and hands you the exact result of how badly you thought through the problem. In minutes.

What AI destroys isn’t the developer’s comfort. It’s the ability to hide—on every side of the table. The person executing can no longer hide behind the mystery of the craft. And the person directing can no longer hide behind other people’s rework.

That’s why the role changes, and doesn’t change back. The developer stops being an executor and becomes a director of intent: their value is no longer in producing the artifact, but in defining precisely what must exist and why. That’s harder, not easier. It’s a promotion disguised as a threat.

The knife cuts both ways

It would be convenient to end here. I’ve written an essay saying AI eliminates the agency cost of the person writing code, and I’m the one directing the work. I walk away untouched.

But if the argument is honest, it includes me too.

I’m an agent as well. My version isn’t laziness—that was never my problem. It’s something else, and harder to see: I defined too little because I could always finish the work myself. I left ambiguity in the air because as long as the problem was poorly defined, no one could prove it had been poorly solved. I held on to control and called it technical judgment. I gamed proxies too; mine were called roadmap, committee, and “this is strategic.”

And the worst part: my own ability to execute was the best hiding place I had. As long as I could patch the holes by working more, I never had to fix the system that kept producing them.

If agency cost goes to zero for the person writing code, it goes to zero for the person deciding what code gets written, too. The same transparency that exposes a team that wasn’t delivering exposes a CTO who wasn’t defining the work.

And honestly, that’s what has me writing this. Not anger at anyone. The discomfort of realizing that the system I’m celebrating is also the first one that can finally measure me.

The status quo of comfort wasn’t theirs.

It was ours.