AI Ate the Translation Layer

For thirty years, software companies ran on a pipeline. Business said why. Product defined what. Engineering figured out how. Each step was its own discipline, its own budget line, its own layer of the org chart. The pipeline needed translators, people who could take requirements from one layer and convert them into the language of the next. Those translators filled the middle of every org chart I ever worked inside.

Ajey Gore calls this the translation layer, and his recent essay on the anatomy of an AI-native org is the clearest framing of what is actually changing that I have read. Not "AI replaces jobs." Something more specific and more interesting. AI ate a task type. The task type was translation.

If your job was mostly converting one well-defined input into a well-defined output, business intent to spec, spec to ticket, ticket to PR, PR to deployment, that task got compressed by an order of magnitude. The title on your badge didn't matter. The task was translation. AI just made it close to free.

The old shape

Every org chart I have seen follows the same shape. A small group at the top deciding why. A larger group in the middle deciding what. A broad base deciding how: engineers, project managers, scrum masters, tech leads, the people who took the what and turned it into running code.

The middle was always bigger than it needed to be. I have argued that before. The cost was invisible because it was distributed: slow meetings, padded tickets, status updates that existed only to justify the next status update. When the cost of translation drops to near zero, the cost of the translators becomes visible for the first time.

Ajey's essay made me sit with something I had been avoiding. Most of what the middle of the org did was not judgement work. It was conversion work. Hard, context-heavy, real conversion work. But still conversion. And conversion is what the models got good at.

The shape that is forming

The new org chart looks different. The why layer stays thin because conviction does not scale with headcount. The what layer grows. Not product managers in the old sense, not ticket-writers, but people who can sit between the why and the agent and make the dozens of small calls per day about what good looks like. This is taste work. This is judgement work.

The how layer shrinks but gets harder. The engineers who stay are not doing ticket conversion. They are designing the harness: the specs, the eval suites, the golden tests, the agent-of-agent review patterns. Someone has to build the system that makes it safe to let agents operate. That someone is an engineer with deep judgement, and there are fewer of them on each team, but each of them is doing dramatically more.

Below all of that, the agents themselves, doing the conversion work. Writing the PR. Updating the doc. Drafting the release note. Reviewing each other's outputs.

The team that is left is smaller in headcount and broader in skill at every level. The middle thinned. The ends thickened. Coordination collapsed. Contribution went up.

I made this same point in Software Ecology and the 10x Moment, about the socio-technical ecosystem that Conway's law predicted. The way you build mirrors the way you organise. When the way you build changes, the organisation has to follow.

The manager problem

The hardest part of this shift is what it means for managers. A lot of engineering managers exist to coordinate translation. They run the standup, unblock the ticket, negotiate priority, write the status update. That work was real and load-bearing. The pipeline did not run without it.

But if the pipeline itself is shrinking, the manager whose entire job was coordinating the translators has a problem. The work that justified the role is dissolving.

I have watched two patterns emerge this year. Denial: managers defending the rituals because the rituals make the role visible. And shift: managers who started writing again or picked up an agent themselves, not to prove a point, but because the org chart underneath them got smaller and the only way to stay useful was to be in the work.

The surviving managers are the ones who contribute to the why, the what, or the trust system that holds the how. Coordination on its own no longer justifies the seat. That is a hard truth for people who spent a decade optimising for being good at the translation pipeline. But the pipeline is getting smaller, and the work underneath it is getting bigger.

What this means for hiring

The hard thing to say out loud: you are going to hire fewer people. The team that does the same amount of work next year will be meaningfully smaller. Not because the people were bad. Because the translation layer collapsed.

Stop writing job descriptions from a 2018 engineering ladder. The senior engineer whose pitch is "I can convert tickets to PRs faster than the next person" is going to be very confused very soon. You need engineers who can define a harness, hold the line on quality, and design systems an agent can safely operate inside.

And hire more what people. Not product managers as ticket factories. People who can hold a thesis, define good in ambiguous situations, and operate the agent themselves rather than handing intent over a wall. The ratio of what to how is about to flip. Most teams are not ready for it.

This is the same argument I made in Software Engineering in the Age of AI. AI amplifies skill, it does not replace it. But amplification only matters if the skill is there. The what layer is where judgement lives, and judgement is the skill that gets amplified most.

What this means for engineers

Do not compete with the agent on translation. The agent will win. It will keep winning, faster, every quarter.

Pick up the work the agent cannot do. Define what correct means. Build the harness. Hold judgement. Take responsibility for outcomes the agent cannot be accountable for. Move toward the what and the why without abandoning the how. The how people who survive are the ones who can still operate at the deepest layer when something genuinely hard breaks.

The middle is the dangerous place to be right now. Not because middle people are bad. Because the middle is where the translation work was concentrated, and the translation work is the work that is going. I wrote about this dynamic in What Happens to Developers Who Don't Adapt to AI. The third group, the watchers, are the ones who built their career on the translation layer and are now watching it dissolve.

The harness design that makes this shape safe is the hard engineering work. Without it, a small team plus agents is a faster way to ship the wrong thing. With it, a small team plus agents is what the rest of the org chart used to look like before we built the translation pipeline on top of it. I covered the mechanism in detail in How I Build Software With Agent Loops, which describes the trust systems and verification patterns that let you operate with fewer people and more agents.

The shape that wins

The work was always the why and the what. We spent thirty years pretending the how was the work, because the how was where the headcount was, and headcount was where the budget was. The headcount is going to move. The org chart is going to follow.

The teams that figure out the new shape first will look unrecognisable to their competitors. Smaller. Stranger. More opinionated. Closer to the work. That is the shape I am watching for. That is the shape I think wins.