In our conversations with tech and engineering leaders over the last year, the same question almost always comes up: If AI handles the code, where does the engineering actually go?

Software engineering is arguably the most disrupted function in business right now, and the most tech-forward companies are adapting.

What we are seeing is that the engineering does not disappear. It just moves. When AI does the typing, the rigor of engineering migrates upstream into writing clear rules, designing tests, and managing risk. Here are our observations of this shift, and its impact on org design.

The merging of product, design, and code: Because AI can generate code and interfaces so cheaply, the old boundaries between roles are dissolving. You used to need a product manager to decide what to build, a designer to draw it, and a developer to code it. Now, those roles are converging. You just need one person who understands the problem deeply enough to supervise the AI solving it.

The temporary junior advantage and the senior bottleneck: Most assume AI will replace junior developers, but right now we are seeing the opposite. Juniors are thriving by adopting AI natively without legacy habits. However, we suspect this is a fleeting state. The real pressure currently lies with senior engineers. Their old job of being the "best coder" is being automated, forcing their value to shift from writing code to managing machine-created complexity. We predict this transition will make senior engineers the next major bottleneck. Moving forward, the engineers who will command the most value are those who can effectively coax AI models to do complex things.

The new engineering burnout: A lot of developers got into this field because they genuinely love the quiet focus of writing code. Now that their daily routine is shifting to constantly reviewing AI output, we are seeing a completely new kind of burnout. It feels like the exhaustion of an editor who desperately wants to be a writer. This could just be a temporary growing pain for a generation that misses their old way of working. The next wave of engineers will probably find their joy in system design. But right now, the people doing the work are feeling creatively starved.

Human approvers are the new bottleneck: A company’s speed limit used to be engineering capacity. Now, that bottleneck has shifted to traditional governance. AI agents can clear a backlog in days, only to hit a wall of human dependencies. Middle managers and legacy compliance gates are turning into massive approval chokepoints. For example, a team might build a feature in an afternoon, only to wait weeks for security sign-off. Without reforming governance alongside engineering, faster teams just hit the same walls sooner.

Budgeting compute instead of headcount: The unit of cost is changing. Organizations used to budget primarily for human hours. Now, the cost is compute. We are seeing engineers burn through millions of AI tokens in an afternoon just to generate, test, and discard code. Managing a tech team now requires an entirely new financial model to balance human salaries against unpredictable machine overhead.

Treating agents as employees: AI agents are no longer just tools; they are actual participants in the operating model. You can instantly duplicate a specialized AI and deploy it across twenty different teams. But this introduces a new structural problem: agent drift. Over time, a database AI on one team learns different local habits than the exact same AI working on another team. Designing an organization now means figuring out how to manage, standardize, and track digital workers just like human ones.