Every age of engineering is defined by what it is forced to count. In A Brief History of Engineering, I frame the period from 1950 to 2050 as the Golden Age of Software Engineering: a century in which software moves from reliability under constraint, to agility through collaboration, to responsibility through autonomous intelligence. This is not just a timeline. It is a moral and technical arc, told through three overlapping archetypes: the Trailblazers of Space and Mainframe, the Rockstars of Internet and Cloud, and the emerging Artificial Engineers. This article takes one signal from that wider story and follows it forward, because what we count reveals what we value, what we fear, and where scarcity has moved.
The Trailblazers of Space and Mainframe counted CPU cycles and memory because the limits were visible. Every instruction carried weight. Every byte had consequence. The machine was scarce, and that scarcity produced a culture of precision. To write software was to practice restraint. Reliability was not an optional quality added later; it was care made executable.
The Rockstars of Internet and Cloud count something different. They count deployments, latency, uptime, users, incidents, lead time and recovery. Their rhythm begins with the internet and cloud, but it continues in every platform team, every open-source workflow, every CI/CD pipeline, and every cloud-native organisation trying to shorten the distance between idea and learning. The Rockstars are not behind us. They are the living delivery layer of modern software engineering.
The cloud made compute feel abundant, but abundance was never the same as freedom. CPU cycles still cost money. Memory still costs money. Storage, bandwidth, GPUs, observability, compliance, and human attention all cost money. The cloud did not make compute free. It made compute elastic. The bill still arrives, only now it arrives through usage dashboards, inference charges, architecture decisions, carbon reports and operational risk.
Now, as Artificial Engineers emerge, another signal joins the stack: tokens. A token is not merely a fragment of text. It is the visible unit of delegated cognition. It measures how much intent we ask a machine to absorb, how much context it must carry, and how much reasoning we are prepared to fund. Tokens are the new cycles, not because CPU cycles stopped mattering, but because tokens sit on top of them. Behind every prompt is silicon. Behind every inference is energy. Behind every generated line of code is a chain of compute, memory, latency, carbon, security and trust.
The AI era has not abolished scarcity. It has made scarcity harder to see. That is the signal beneath the signal. Code is becoming cheap to generate, but it is not becoming cheap to trust.
The Signal Stack
The mistake many organisations will make in this new era is to optimise the wrong thing. They will measure tokens per second, cost per prompt, lines generated, stories completed or applications launched. These are useful signals, but they are not the destination. The destination is a trusted outcome.
The old signals still matter. CPU and GPU usage tell us that intelligence has a material cost. Memory tells us that context has boundaries. Latency tells us that every delay has an experiential price. Token usage tells us how much cognition we are delegating. Speed tells us how quickly intent can become artifact. But none of these signals is sufficient alone. The new engineering discipline is to understand how they combine.
Physics, cognition, flow, trust and value now form a single signal stack. At the bottom is the material cost of intelligence: CPU, GPU, memory, energy and carbon. Above that sits the cost of interpretation: tokens, prompts, context windows and reasoning traces. Above that comes the speed of manifestation: the distance between idea and working artifact. Above that sits the cost of confidence: verification, policy, observability, human review and audit. At the top is the only question that really matters: did the work produce a trusted outcome?
This is the next abstraction of engineering performance. In the first era, we measured whether the machine could execute. In the internet and cloud era, the Rockstars measure whether the organisation can learn. In the agentic era, we must measure whether intelligence can produce outcomes we can trust. The north-star metric becomes Cost per Trusted Outcome, a phrase that resists the shallow economics of AI. A cheap prompt can still produce an expensive mistake. A fast agent can still create a slow incident. A generated application can still become a governance liability. The real cost of AI-enabled engineering includes compute, memory, context, human review, security validation, operational risk, carbon, and the cost of being wrong.
Scarcity Has Moved
In the mainframe era, scarcity lived in the machine room. In the internet and cloud era, it lives in the bill, the bottleneck, the incident queue and the team’s attention. In the AI era, scarcity lives inside inference, context, verification and trust.
This matters because the rhetoric around AI often implies that creation is becoming free. It is not. Creation is becoming compressed. The cost is not disappearing; it is migrating. CPU still costs money. Memory still costs money. GPUs cost money. Latency costs trust. Energy costs the planet. Human review costs time. Security failure costs reputation. Bad intent costs society.
What is collapsing is not the cost of software as a whole. It is the cost of producing certain forms of software expression. Boilerplate is cheap. Syntax is cheap. First drafts are cheap. Test scaffolds are cheaper. Basic integrations are cheaper. Documentation can be generated. Deployment manifests can be assembled. Interfaces can be sketched by models. Agents can increasingly reason across repositories, tickets, logs and designs.
But cheap expression is not the same as cheap engineering. The repetitive expression of software is being commoditised. The responsibility for software is not. That distinction is critical.
Code Becomes Consumable
For much of what I call the Golden Age of Software Engineering in the book, code has been treated as a durable asset. It lives in repositories. It accumulates history. It carries ownership, documentation, dependencies and debt. Organisations protect code because it is expensive to produce and expensive to replace.
Agentic engineering challenges that assumption. If an intelligent system can describe an application, generate its code, test it, deploy it, observe it, learn from it and discard it, then code stops being the primary asset. It becomes scaffolding. Useful, necessary and consequential, but no longer sacred.
The value moves upstream into intent, context, policy, data, verification and memory. This is where the book’s concept of Intentware becomes important. I introduce Intentware as the next medium after software: not a product category, not a tool, but a way of naming the shift from instruction to purpose. Hardware worked through matter. Software worked through logic. Intentware works through structured intent.
Intentware asks a different question from traditional software. Not simply, “what should the code do?” but “what outcome should exist, why should it exist, under what constraints, and how will we know it can be trusted?” In that world, the artifact matters less than the understanding it leaves behind. Code may be generated for a moment, used for a task, then dissolved. What remains is the reasoning: what was asked, why it was allowed, what constraints applied, what it cost, how it behaved and what was learned.
That is not the end of engineering. It is the migration of engineering into a higher layer of meaning. The engineer does not vanish. The engineer moves from syntax to stewardship.
The Commoditisation of Software Engineering
Commoditisation is often misunderstood as decline. In engineering, it is usually a sign of maturity. Yesterday’s elite practice becomes today’s platform default. Version control was once specialist discipline. Continuous integration was once advanced practice. Automated testing was once a mark of serious engineering culture. Observability, security scanning, infrastructure as code, feature flags, deployment automation and platform engineering all began as practices that required expertise, advocacy and cultural change. Over time, the best of them become defaults.
The same pattern is now unfolding with AI-assisted engineering. The practices that define high-performing teams are increasingly encoded into agents, platforms and policies. Test generation, threat modelling, dependency review, environment creation, performance tuning and documentation become capabilities that surround the engineer rather than tasks the engineer performs from scratch.
This does not remove craft. It raises its altitude. The craft becomes knowing what to ask, what to constrain, what to verify and what to reject. The scarce skill is no longer typing code. It is framing intent. The best engineers will not be the ones who generate the most software. They will be the ones who define the clearest outcomes, constraints, measures of truth and boundaries of acceptable action. They will understand that ambiguity, once merely frustrating, is now dangerous. When creation becomes instant, ambiguity becomes executable.
The Unbundling of SaaS
This is why the “death of SaaS” debate matters, but only if we treat it carefully. SaaS will not simply vanish. Institutions, contracts, data models, integrations, compliance regimes and customer trust do not disappear because a new interface arrives. History rarely works that cleanly. What may die is the fixed application as the default unit of work.
Satya Nadella’s more careful formulation points in this direction. In Microsoft’s January 2025 CoreAI memo, he described 2025 as a year of model-forward applications, argued that every layer of the application stack would be affected, and wrote that agents would change every SaaS application category. He also used the phrase “service as software,” which captures the inversion well: the outcome becomes the product, and software becomes the temporary form that delivers it. (blogs.microsoft.com)
Traditional SaaS bundles data, workflow, business logic, user interface, permissions, reporting, audit and commercial packaging into a single product experience. Agentic systems start to pull those elements apart. The data may remain in systems of record. The workflow may be orchestrated by agents. The business logic may move into an AI tier. The interface may be generated at the moment of need. Reporting may become conversational. Audit may become a reasoning ledger. The user may no longer “go to” an application at all.
A CRM screen becomes a temporary surface around a customer intention. A dashboard becomes an answer space around a question. A procurement system becomes a policy-guided negotiation. A support application becomes an agentic service that resolves, explains and records. The application becomes less like a place and more like a moment, less monument and more manifestation.
This is not the death of SaaS as a revenue model, vendor category or enterprise reality. It is the unbundling of the application as the primary container of work. The Rockstar layer remains essential here, because the cloud, APIs, DevOps, platforms and open ecosystems make this unbundling possible. AI does not replace that foundation. It accelerates and rearranges it. The future may not be simply software as a service. It may be service as software.
The Return of Discipline
The irony of the AI era is that it may return us to the discipline of the Trailblazers. The early engineers respected every cycle because they could see the cost. Modern engineers must learn to respect every token, every watt, every inference and every autonomous act, even when the cost is hidden behind abstraction.
We are returning to scarcity, but at a higher level. The old scarcity was memory and cycles. The new scarcity is meaning and trust. The Trailblazers teach us that precision is care. The Rockstars teach us that feedback is learning. The Artificial Engineers must teach us that autonomy requires accountability. The signal stack is not just technical. It is moral.
Tokens ask how much cognition we are delegating. CPU and GPU ask what intelligence costs in matter and energy. Memory asks how much context the system can hold before meaning degrades. Speed asks whether governance can keep up with manifestation. Trust asks whether we can explain why the system acted. Value asks whether the outcome was worth creating. This is where Cost per Trusted Outcome becomes more than a metric. It becomes a philosophy of modern engineering.
The New Scarcity Is Trust
When code becomes abundant, confidence becomes scarce. When applications become ephemeral, memory becomes sacred. When systems act on intent, clarity becomes infrastructure. This is the next discipline: not prompt engineering, but intent engineering. It is the ability to express outcomes, constraints, policies, values and measures of success so clearly that machines can act without losing the human thread.
The coming engineering organisation will need new primitives. It will need reasoning ledgers, natural language twins, policy-aware platforms, carbon-aware orchestration, agent observability, human override loops, semantic testing and trust budgets. These are not decorative ideas. They are the structures required when software becomes fluid. The old repository preserved code. The new ledger must preserve why.
Conclusion: The Artifact Is Being Commoditised, Not the Accountability
The history of software engineering is a history of rising abstraction. We move from hardware to software, from software to platforms, from platforms to agents, and now from agents toward intent. At each stage, the old craft appears to disappear. It does not. It moves.
The command line does not end engineering. The compiler does not end engineering. The cloud does not end engineering. AI will not end engineering either. But it changes where engineering lives. It lives less in syntax and more in stewardship, less in permanent applications and more in trusted outcomes, less in durable artifacts and more in durable reasoning.
The next great metric will not be tokens per second, deployments per day or lines of code generated. It will be Cost per Trusted Outcome. Software may become ephemeral, applications may become temporary, code may become consumable and SaaS may be unbundled, but trust will not become cheap. Trust is the new scarcity. Intent is the new source code. Engineering, at its highest form, remains the promise that what we build will serve.
Like this article? Join the update list.