AI turned software engineers into architects. What's above architect?

For decades, being a software engineer meant doing the construction yourself. You ran the plumbing, pulled the electrical, hung the drywall: wrote the functions, wired the integrations, patched the leaks at 2am. Senior engineers were master builders, people who'd swung every hammer on the site.

That's not the job anymore. With agentic tools like Claude Code and OpenAI's Codex writing, running, testing, and debugging code on their own, the engineer increasingly works the way an architect works a construction site: draw the plans, write the contracts, inspect the work, sign off on what stands. Anthropic has described enterprise engineering where AI writes the large majority of code, with humans shipping in weeks what took quarters.

I've built engineering organizations through both eras, and the strange part isn't the productivity. It's the identity shift. The engineers thriving now aren't the fastest typists; they're the clearest thinkers, because the bottleneck moved from construction to specification.

Stanford's analysis of ADP payroll data found employment for software developers ages 22 to 25 down nearly 20% from its late-2022 peak by September 2025, while older engineers in the same fields grew. ADP's own chief economist reports the same 20% drop, so two independent reads of the data agree. That's exactly what you'd expect when the construction tier gets automated: the apprentice work disappears while the architect work appreciates, the same split we covered in new grads vs experienced professionals.

This is not a one-time snapshot. Stanford and ADP now track it monthly in a live canaries dashboard, and the early-career gap in AI-exposed software work has held as the numbers refresh. The signal has held long enough to plan around, so build the architecture-tier skills now instead of waiting to see if it reverses.

The skills that survived the move up are telling: system design, code review at speed, writing specifications precise enough for an AI crew to execute, and the evals and tests that catch bad work before it ships. Notice that every one of those is judgment expressed in language. The job is becoming directing-and-verifying, which is why engineers who treat prompting and context engineering as beneath them are quietly falling behind people two levels their junior.

Architect isn't the top of the ladder, and the ladder is still moving. The work architects do today, decomposing a system, writing the spec, reviewing the diffs, is already being partially absorbed by the same tools, which now plan multi-step builds and review their own output before a human ever looks.

So the human slot keeps shifting toward what a developer-and-owner does in construction: deciding what gets built at all, for whom, on what budget, to what standard, and bearing the consequences. Problem selection, taste, accountability, and trust are the layers AI absorbs last, because they're not about producing artifacts. They're about owning outcomes.

That's not a reason for fatalism; it's a direction to skate. Every rung the ladder moves makes one engineer more powerful, and the engineers who climb deliberately, learning to direct AI crews instead of competing with them, are having the best careers of their lives right now.