Not long ago, deploying a server meant racking hardware. You installed an operating system, configured the networking, ran the cables, labelled everything and hoped you hadn't missed a firmware update that would bite you at 2am on a Saturday. It was physical, skilled work and the people who did it well were invaluable.
Then infrastructure-as-code collapsed all of that into a few lines of Terraform. The servers didn't disappear. The metal is still very real: someone at AWS, Azure, or GCP is still racking hardware and running cables in a data centre somewhere. But the vast majority of engineers will never touch it. The work shifted from hands-on-metal to designing systems at a higher level of abstraction. Engineers who adapted weren't the ones who mourned the loss of the server room. They were the ones who recognised that the valuable skill had moved upstairs, and followed it.
Now the same compression is happening again. Not just to infrastructure, but to delivery, solution design, and increasingly to the judgement work that sits above both. It's happening faster than any previous shift.
Abstraction isn't new, but the speed is
Every generation of tooling pushes the valuable work one level up. Assembly gave way to high-level languages. Manual testing gave way to automated pipelines. Hand-configured servers gave way to declarative infrastructure. Each time, the work that mattered shifted from execution to design, from doing to defining.
What's different now is the interval between these abstraction layers. It used to take years for a new layer to mature. With agentic AI, we're watching it happen in months.
Software engineering is the canary of agentic utility. According to Anthropic's own research, coding accounts for 52% of current AI agent usage. That highlights where agents have landed first with the biggest impact. But the work hasn't disappeared. It's moved from writing boilerplate code to scoping, reviewing, and validating code. You're not coding every line of solution any more. You're describing the solution and verifying what comes back. That's an evolving skillset, more emphasis on architecture, quality assurance and security research than on traditional development.
The catch is that the verification layer has to keep pace. When teams adopt AI-assisted production without rethinking how they review and validate, a gap opens up. The work moves upstairs but the process stays on the ground floor. Closing that gap is less about adding more reviewers and more about rethinking what "upstairs" work actually consists of.
The weight of the next floor up
As the work compresses, the person overseeing it does not get a lighter load. They get a different one, and in many respects a heavier one.
When an engineer or architect was responsible for building a feature, the scope of their attention was relatively contained: the code, the tests, the immediate integration points. The work was deep but narrow. Now, with agents handling much of the execution, that same person is expected to hold the full breadth of concerns simultaneously. Security implications, scaling considerations, functional correctness, testing strategy, change management, data governance, accessibility, performance, compliance. That is one person, on one afternoon, reviewing what an agent produced in an hour. Each of these is a discipline in its own right, and each demands a different kind of judgement.
This is the cognitive load problem that most organisations have not yet accounted for. The assumption is that because the production work is faster, the person supervising it has capacity to spare. In practice, the opposite is often true. The speed of production means that decisions which used to be spread across weeks of development now need to be made in hours. An agent can scaffold an entire service in an afternoon, but the human still needs to assess whether it handles edge cases correctly, whether it introduces a security surface that did not exist before, whether it aligns with the broader architecture, and whether it will be supportable by the team that inherits it. Those judgements cannot be automated, and they cannot be rushed without consequence.
The discomfort this creates is worth making clear. If your teams are valued for their ability to produce, and development is being abstracted away, what remains? The answer is judgement across all of these dimensions at once. Knowing what to build, for whom, and why. Knowing when the output looks right but is not. Knowing what the business actually needs versus what the requirement document says. These have always been the hardest parts of any project. The difference is that they used to be surrounded by enough execution work to obscure their importance, and to give the person time to consider each one in turn rather than all at once. As the work compresses, they are exposed as the core of the value, and the cognitive demands of managing them concurrently are significant.
What "upstairs" actually looks like
The roles that matter most in an AI-augmented world aren't new. They're the roles that were always more esoteric: scoping, stakeholder alignment, domain understanding, verification, and organisational readiness. These used to be treated as overhead. Now they're the product.
Consider the decision-making problem. It's a pattern common across the industry: the technical execution of a project takes weeks, but internal decision-making takes months. Approvals queue up, stakeholders need re-alignment, sign-off cycles stall. In a world where execution compresses to days or hours, your organisation's ability to make decisions and act on them becomes the dominant variable in every project timeline. The bottleneck is no longer how fast things can be built, it's how fast your organisation can decide what it wants and validate what it's received.
The organisations that adapt won't just retrain their people on AI tools. Training people to use the tools is necessary but insufficient, like teaching someone to drive without teaching them how to navigate. The real restructuring is around the work that remains irreducibly human: defining outcomes, aligning stakeholders, making risk judgements, holding accountability for what gets done and being able to tell the difference between output that satisfies a specification and output that actually grows value.
Moving faster is not the same as delivering well
The engineers who stopped racking servers did not become less valuable. They became cloud and reliability engineers, operating at a higher level of abstraction where the decisions carried more consequence, not less. The same shift is happening now across every discipline that agentic AI touches. And upstairs, the currency is human judgement: the ability to assess, verify, and decide across security, architecture, compliance, change management, and business value simultaneously. Every abstraction layer that accelerates work places more weight on that judgement. The organisations that recognise this will invest accordingly. The ones that do not will discover that moving faster and delivering well are not the same thing.
