The Anatomy of an AI-Native Org

If you draw the org chart of any software company built in the last thirty years and squint, the same shape shows up. The org chart we never named There’s a small group at the top deciding why — why we exist, why this market, why now. Below them, a slightly larger group deciding what — what to build, what to ship, what to cut.

And underneath both of those, the broad middle of the company, the part where the headcount actually lives — the how. Engineers, project managers, scrum masters, tech leads, engineering managers, program managers, who took the what and translated it into code, into tickets, into deployments, into release notes, into Slack messages in #releases. I’ve been part of every layer.

I’ve sat in the why room. I’ve run the what meetings. I’ve shipped a lot of how.

I’ve also argued, for a long time and in a lot of rooms, that the middle of that pyramid was bigger than it needed to be — that leaders should be co-workers, not reviewers, and that managers who only managed were a tax the team paid for the privilege of having a status meeting. That argument never quite landed either. Same shape as the one I lost about tests — the cost was paid in slow, distributed ways that nobody in the room wanted to add up.

What’s on my mind a year into the agent shift is that the bill is finally getting itemised. And the line that’s getting cut is the one I’ve been pointing at for years. Most of what we did in the middle was translation.

Business intent translated into product spec. Product spec translated into JIRA ticket. JIRA ticket translated into a branch name and a PR.

PR translated into deployment. Deployment translated into a release note. Release note translated into a status update.

Status update translated back upward into business language. Each step had its own ceremony, its own job title, its own meeting cadence. A whole industry of frameworks — Agile, SAFe, Spotify model, you name it — grew up around making the translation pipeline more efficient.

We were, mostly, glorified translators. I include myself in that. I include most of the best engineers I’ve worked with.

The work was real and hard and required taste, but the shape of it was conversion. Take the thing in this language, output the thing in that language. Repeat.

What AI actually ate The agent conversation keeps getting framed as “AI replaces engineers” or “AI replaces customer service” or “AI replaces analysts.” All of those framings are slightly wrong. AI didn’t come for a job title.

AI came for a task type, and the task type it came for was translation. If your job was mostly converting one well-defined input into a well-defined output — natural language to SQL, requirements to code, ticket to PR, design spec to working component, log line to incident report, customer email to ticket — your task got compressed by an order of magnitude. Doesn’t matter what your title was.

The task was translation. The task got cheap. The two ends of the pipeline didn’t get cheap.

Defining why — the business reason, the strategic call, the bet — is harder than ever, because the cost of executing on a bad why just dropped to nearly zero, which means more bad whys are going to ship, faster, with more confidence. Defining what — the product call, the cut decision, the “we will not build that even though we could” — is harder than ever, because the cheaper execution gets, the more options you have, and judgement under abundance is its own discipline. The middle is what got eaten.

And the middle is where most of the org chart lives. Hold that honestly. Not as a doom story.

As a fact about the shape of work. The manager who doesn’t contribute Here’s a hard one, because it’s about people I’ve worked with and respected. A lot of engineering managers exist to coordinate translation.

They run the standup. They unblock the ticket. They negotiate priority across teams.

They write the status update. They translate engineering progress upward into business language and business priorities downward into engineering language. That work was real.

It was load-bearing. The pipeline didn’t run without it. But if the pipeline itself is shrinking — if the layers between why and shipped code are collapsing because agents can carry more of the conversion themselves — then the manager whose entire job was coordinating the translators has a problem.

The work that justified the role is dissolving. I’ve watched two patterns emerge over the last year. One is denial — managers who quietly defend the rituals (the standup, the status meeting, the JIRA hygiene) because the rituals are what make the role visible.

The other is the shift — managers who started writing again, designing again, defining again. Who 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. I don’t think every manager needs to write code.

I do think every manager needs to contribute — to the why, to the what, t