---
title: "When AI writes the code, the architect's job is the elevator ride"
description: "Gregor Hohpe's architect elevator matters more when AI makes the engine room cheap, because the ride itself is now the whole job."
url: "https://michael.zazon.us/notes/when-ai-writes-the-code-the-architects-job-is-the-elevator-ride"
published: "2026-07-27T12:00:00-04:00"
kind: "book-notes"
subject: "architecture"
tags: ["ai-coding"]
---
If AI agents are writing most of the code in the engine room, does the big company still need someone to ride between the engine room and the penthouse? This is a 2026 update to a question posed in Gregor Hohpe's [The Software Architect Elevator](https://architectelevator.com/book/) (O'Reilly, 2020) about the purpose of an architect in a large organization. My answer is yes, and riding is now the bulk of the job.

I've spent ten years working with large financial institutions and Fortune 500 companies. My current role as a principal cloud architect puts me on the elevator by definition. Before that I was a developer, development manager, infrastructure manager, sysadmin, small business owner, and consultant.

In Hohpe's building, the executives work in the penthouse, the IT folks work in the engine room, and there are many management floors in between. Information takes the stairs, but it loses meaning on each floor (telephone game style), so the executives end up funding the wrong things and innovative engineering projects don't get the support they need. The architect rides the elevator both ways, translating strategy into architecture and bringing execution learnings back up. And then keeps riding.

That's all in [his original essay on martinfowler.com](https://martinfowler.com/articles/architect-elevator.html), and one of the ideas people often call out is that an architect needs to be able to speak the language of every floor they interact with.

In the same essay, he writes "most of what architects have traditionally done should be done by developers, by tools, or not at all." This was written years before coding agents, so the "by tools" part is now literal. If developers (and agents) can do the drawings and the boilerplate, then the architect is left with the part that can't be delegated: the ride itself.

The case for the ride is even stronger when you consider what agents changed. Writing code is now practically free, but knowing for sure that a change is right hasn't gotten any cheaper. Addy Osmani talks about this in [Agentic Code Review](https://addyosmani.com/blog/agentic-code-review/).. how the constraint moved downstream to verification, and how review rigor should scale with the change's blast radius. GitClear's data, which Osmani cites, shows daily AI users writing ~4x more raw code for ~12 percent more delivered value.

This changes what the penthouse sees: a working demo in days. The temptation for executives is to read that as a solved problem and write off the architect as overhead. But I think the most valuable trip now is upward, carrying what the demo hides. Missing from the demo are the verification cost and how far failure spreads. Also absent are the run cost and the regulator's questions.

Also carried up is the gap between what the business says it needs and what it actually needs. That's the job. I think cheap code widens that gap: the agent builds what was asked, quickly and convincingly, even if the request was wrong.

[Diagram: What the architect carries up to the penthouse and down to the engine room](https://michael.zazon.us/notes/when-ai-writes-the-code-the-architects-job-is-the-elevator-ride)

The strongest pushback is that architects who stopped coding are an ivory tower anti-pattern, and senior engineers do architecture anyway, so AI just removes another layer of overhead. Another common complaint is that architects rarely have a manager's mandate, so their word only counts if backed by leadership.

They're right about architects only riding the top floors. An architect who doesn't touch the engine room has stopped riding. In 2026, staying in the engine room means using the same agents and pipelines as your teams. The mandate point is fair.. having the answer is easy, but the elevator is worthless if you can't decide and own, and that comes from leadership. I split the work: delegate low-level design, own the contracts between systems, dive in only where the risk lives.

If an engineering leader asks me if architects are worth the chair, I'd say: keep them, but measure them on translation, not diagrams. Did decisions get made faster? Did we reverse course less often? Did AI pilots get killed early or scaled for reasons we can state clearly? Expect them to use the same tools your teams do, hands-on. Give them a seat at the table where AI investment gets decided.

Hohpe says architecture is about selling options. Cheap code means cheap options.. your team can build several versions of almost anything in the time it took to build one before. Now the architect's job is to price those options, decide which ones are worth verifying and running, and kill the rest before they hit production.