Execution Is Free. Alignment Is the Tax Now.

For most of software history, building was the hard part. Writing the code, testing it, shipping it. That took weeks. By comparison, the meetings to agree on what to build felt cheap.

So we paid the coordination cost without thinking about it. A few extra syncs to align the team was worth it, because the real money went into execution.

AI flipped that math. You can now ship a feature in an afternoon. But you still spend weeks getting people to agree on what the feature should be. The cost of building fell off a cliff. The cost of agreeing did not move.

That gap is the alignment tax. And it is now the biggest line item on the bill.

What the alignment tax actually is

It is not the time spent typing code. It is everything around it that needs a human:

• Agreeing on what to build in the first place
• Communicating the intent clearly enough that it gets built right
• Reconciling stakeholders who want different things
• Checking that what came out is actually what you meant

None of this is execution. All of it is alignment. And unlike execution, you cannot hand it to an agent, because the whole point is deciding what the agent should do.

Why it suddenly dominates

Speed up one part of a system and the slow parts start to show. The work that used to hide behind a slow step is now the thing holding everything up.

That is what happened to software. Typing got cheap, so every step around it now looks expensive. Fred Brooks said as much in 1986 in No Silver Bullet: the hard part was always the thinking and agreeing, not the typing. Make the typing free, and the thinking and agreeing become the whole job.

The data is catching up to him.

Agoda looked at its own AI rollout and found that individual output went up, but project speed barely moved. The wait was never the typing. It was the humans on either side: agreeing on the goal, then agreeing the result matched it.

Zendesk hit the same wall. It reported that AI made code abundant, so the constraint moved to "absorption capacity": how much new work humans can actually agree on, understand, and trust. Faster machines just push the bottleneck onto the people around them.

It is human, and it scales badly

The alignment tax grows with people, not lines of code.

Brooks gave us the math decades ago in The Mythical Man-Month. The number of communication channels in a team is n(n-1)/2. Three people have three channels. Fifty people have 1,225. Every channel is a place where intent can get lost.

AI does nothing to shrink that number. If anything it raises the stakes, because each person can now produce far more output that everyone else has to keep track of. Tomasz Tunguz calls this the communication tax: the machine writes the code, so human communication becomes the thing that sets your speed.

AI makes it worse before it makes it better

Cheap execution has a sharp edge. When building was slow, a misunderstanding surfaced slowly too, and you had time to catch it. Now you can generate the wrong thing in an afternoon.

Speed does not fix misalignment. It ships it faster. A vague spec used to cost you a slow week of building the wrong feature. Now it costs you a fast day, plus the review time to figure out why the output feels off, plus the rebuild. The tax compounds.

So the job changes

If alignment is the cost, then clarity is the work.

The valuable skill is no longer producing the thing. It is describing the thing precisely enough that it gets produced right the first time. That means requirements, specs, and shared written context, not vibes passed down a hallway. It means asking "should this even exist" before "how do we build it."

The scarce person is no longer the one who can build fastest. It is the one who can take a fuzzy goal and turn it into something unambiguous. Writing clearly is now the same as thinking clearly, and thinking clearly is the bottleneck.

How to pay less tax

A few things lower the bill:

• Keep teams small. Fewer people means fewer channels and less intent lost in translation. The communication math punishes size.
• Write specs, not tickets. A precise spec is the interface between a human and an agent. The clearer it is, the less you pay later in review and rework.
• Verify against outcomes, not lines. Check that the result does what you meant, not that every line looks right. Reviewing line by line does not scale when the machine writes most of it.
• Make context shared and written. What is in one person's head is a tax waiting to be paid. What is written down once gets reused for free.

The bottom line

Execution went to zero. The bill did not disappear. It moved.

The cost is now in the human parts: agreeing, communicating, deciding, verifying. Those do not get cheaper when the model gets better, so they end up being most of what you pay for.

The teams that win in this era are not the ones that build fastest. Everyone builds fast now. They are the ones that pay the least alignment tax.