Everyone is trying to improve their coding agent. Make it faster. Make it cheaper. Make it better at pull requests. Make it refactor legacy code. Make it write tests. Make it understand the repository. Make it act like a senior engineer with infinite patience and no sleep. Fine. But it is not enough. In fact, it may be the wrong obsession.
The industry is staring at the keyboard while the real transformation is moving above it. We are making better agents to write code, but we are not making better systems to preserve intent. We are accelerating implementation while leaving purpose trapped in tickets, meetings, Slack threads, strategy decks, compliance documents, and half-remembered conversations. We are teaching machines to generate software faster than we are teaching our organisations to remember why that software should exist. That is the gap, and we are falling behind. Not because our coding agents are weak. They are improving at extraordinary speed. We are falling behind because our systems of intent are almost nonexistent. The next order-of-magnitude gain will not come from agents that write code faster. It will come from systems that preserve intent better.
We are falling behind because we have forgotten the oldest definition of the craft. To engineer is to promise. It is not merely to produce code, merge branches, or deploy features. It is to make a commitment that something will behave in the world with enough reliability, clarity, and care that other people can depend on it. A bridge is a promise that people may cross safely. A spacecraft is a promise that human beings may leave the Earth and return. A payment system is a promise that value will move without betrayal. A software system is a promise that thought can be made reliable. The problem is that our current AI tooling is mostly aimed at the mechanics of that promise, not the promise itself.
Coding agents are becoming astonishing. They can scaffold services, migrate APIs, summarise codebases, generate tests, and produce plausible architecture at speed. They are already changing the economics of software delivery. But most of them still operate inside a narrow frame: given a task, produce an artefact. Given a bug, propose a fix. Given a repository, make a change. That is useful. It is not enough. Because the deepest failures in software rarely come from a lack of code. They come from a loss of intent. The system did what the ticket said, but not what the customer needed. The platform optimised the metric, but damaged the experience. The AI agent completed the task, but misunderstood the purpose. The team shipped the feature, but no one could explain why it mattered six months later. The dashboard went green while the promise fell through the cracks.
Here is the risk we do not want to admit: better coding agents may actually make this problem worse. If we give agents vague intent, they will produce vague systems faster. If we give them shallow goals, they will optimise shallow outcomes at scale. If we give them incomplete context, they will confidently fill the gaps with probability. The result will look productive. It will feel magical. It will create a beautiful downward graph. But it may not preserve the thing we were meant to protect. A support agent asked to reduce waiting times can close tickets faster. It can route customers through scripted loops, declare issues resolved, and report operational improvement. But a wiser system asks whether the customer was actually helped. The first system optimises the queue. The second preserves the purpose. That difference is everything.
Right now, too much of the AI race is focused on the first system. We are building agents that can move work through the queue faster. We are not building enough systems that can understand what the queue is for. This is why “AI for coding” is too small a frame. The real opportunity is not merely to make coding agents ten percent better. It is to use AI to make systems of intent work by an order of magnitude. A system of intent is software that carries its purpose, constraints, reasoning, evidence, and accountability alongside its execution. It still contains services, data, APIs, pipelines, interfaces, and runtime behaviour, but it also carries the reason those things exist. It is not only a system that runs. It is a system that remembers why it was asked to run.
That is where AI should be pointed: not just at code generation, but at intent preservation, reasoning capture, promise management, and the living thread between strategy and system behaviour. Because today that thread is broken almost everywhere. Executives define outcomes in presentations. Product teams translate them into roadmaps. Analysts turn them into requirements. Engineers turn them into tickets. Agents turn tickets into code. Operations teams observe behaviour in production. Compliance teams inspect evidence after the fact. Somewhere along that chain, meaning evaporates. By the time the system is live, nobody can fully trace the path from original intention to machine action. The code exists. The pipeline exists. The dashboard exists. But the promise has been scattered across tools that were never designed to remember it.
That is the real technical debt. Not old code. Lost intent. The industry keeps talking about legacy systems as if they are mostly COBOL, monoliths, and brittle integration layers. But the deeper legacy problem is that most organisations cannot explain why half their systems behave the way they do. They know what exists. They know who owns it. They may know whether it is up or down. But they cannot always say what promise it is keeping, what assumption it encodes, what trade-off created it, or whether that trade-off still holds. Now add AI agents to that environment, and the outcome is not mysterious. DORA.dev’s research has already pointed to the pattern: AI amplifies the good, the bad, and the ugly. Strong engineering systems get stronger. Weak systems get louder, faster, and harder to govern. A coding agent inside a weak system of intent is not a revolution. It is an accelerant poured onto ambiguity. It is inevitable.
This is why engineers must move up the stack. The first generation worked near hardware, counting cycles and memory by hand. The next moved into languages, frameworks, networks, and platforms. The cloud generation stepped further away again, shaping infrastructure through declarations, pipelines, and policy. AI continues that ascent, but not without consequence. It moves engineers further from syntax and closer to judgement. Engineers are not leaving code behind. They are moving through it, above it, and around it, until the primary artefact is no longer syntax alone, but intent. At first, engineers will still read and write code. They will still inspect pull requests, reason about systems, and understand the machinery beneath the abstraction. But less of their value will come from producing syntax directly. More will come from framing the problem, defining the constraints, reviewing the reasoning, and validating the outcome. Gradually, the engineer moves further from code and closer to intent, until stewardship becomes not a new job title but the natural destination of the craft.
Coding agents operate at the level of implementation. Systems of intent operate at the level of purpose. Stewards operate in the gap between them. That gap is where the future will be decided. This is where the industry is underinvesting. We do not need only better coding agents. We need agents that work above code: agents that preserve intent, test reasoning, expose trade-offs, trace accountability, and ask why before they build how. We need AI that helps organisations remember. Not just feeding dopamine tokens into the coding monkey and mistaking the next generated function, green test, or pull request for progress. That is activity. The work now is alignment.
If intent becomes the source of truth, then reasoning needs a record. The reasoning ledger will become as important as the deployment log. It should record why an agent acted, what evidence it used, which constraints shaped its decision, and where human judgement entered the chain. In practical terms, it becomes the place where prompts, policies, model choices, approvals, exceptions, assumptions, trade-offs, and interventions are preserved as part of the system record. It gives leaders, engineers, auditors, and agents a shared memory of why the system acted. Without such a ledger, autonomous systems become amnesiac. They may know what they did, but not why. They may act with speed, but they cannot be trusted with memory. They may produce outcomes, but they cannot explain their obligations. A system without memory of intent is fast, useful, and forgetful. In human terms, that is dangerous. In engineering terms, it is untraceable.
And yet this is exactly where many organisations are heading. They are plugging coding agents into development workflows while the deeper intent architecture remains fragmented or nonexistent. They are automating the bottom of the stack before making the top of the stack coherent. They are improving the velocity of implementation without improving the fidelity of purpose. That is not transformation. That is acceleration without memory. Sol Rashidi puts the discipline plainly: “Outsource your tasks. Never your thinking.” That should be written above every AI initiative, every agentic platform, every automation roadmap, and every executive dashboard promising productivity without asking what kind of intelligence is being preserved.
Steve Jobs understood that technology at its best disappears into the experience. The highest craft feels obvious after it has been done. But in the age of AI, disappearance alone is not enough. If the machinery disappears, the intent must become more visible, not less. If code fades into conversation, the promise must become sharper. Beauty without accountability is theatre. Simplicity without traceability is risk wearing a clean interface.
This is the paradox we refuse to confront. The better the AI interface becomes, the easier it is to stop asking hard questions. The answer arrives instantly. The code compiles. The prototype looks convincing. The graph improves. The demo lands. But beneath the ease lies a chain of inference, model behaviour, permissions, data choices, policy assumptions, and hidden trade-offs. If those assumptions are not visible, the experience may be beautiful, but the system is not trustworthy. The next great engineering platforms will not merely manage code. They will manage promises. They will preserve intent across teams, agents, models, deployments, incidents, and time. They will make it possible to see whether a system remains aligned with the purpose that created it. They will treat drift from intent as seriously as drift from configuration. They will make meaning observable.
That is the real step change: not a coding agent that writes a function slightly faster, but a system of intent that makes the organisation less vulnerable to its own ambiguity. That sounds harsh. It should. Because too much of modern software work is still organisational amnesia disguised as delivery. We move faster than we understand. We generate more artefacts than we can govern. We automate workflows whose purpose no one has revisited. We celebrate throughput while the original promise fades into the background. AI should not only help us write more code. It should help us become honest about why the code exists.
The old craft asked whether the machine could be made to obey. The cloud craft asked whether teams could deliver safely at scale. The emerging craft asks whether intelligent systems can pursue our goals without losing our values. That is a different question. A harder question. A better question. Privacy is not a setting. Safety is not a test stage. Fairness is not a dashboard after deployment. Sustainability is not a line in a strategy deck. These are not decorations placed around the system after it is built. They are part of the intent itself.
This is why the future engineer will not be measured by how close they remain to code, but by how clearly they can preserve intent as the work moves up the stack. Their value will lie in the clarity of their questions, the precision of their constraints, the resilience of their systems, and the honesty of their feedback loops. They will not simply ask, “Does it work?” They will ask, “What promise is it keeping?” The past rewarded engineers who could make systems run. The future will reward those who can make systems remember.
And this is where we are behind. The coding-agent race is easy to understand: better code, faster delivery, lower cost, fewer defects. Every executive can understand that pitch. Every vendor can sell it. Every team can try it. Systems of intent are harder. They require organisations to confront ambiguity, expose contradictions between stated values and operational incentives, and turn alignment from a slogan into an engineering discipline. No wonder the industry prefers coding agents. Coding agents let us feel advanced without becoming honest. Systems of intent will demand honesty. They will ask whether the metric is the mission, whether the roadmap still reflects the promise, whether the agent did the right thing for the right reason, whether the system is optimising the business or hollowing out the experience, and whether we are building what matters, or merely building what can be measured. This is not bureaucracy. It is conscience made operational.
To engineer is to promise because engineering changes the future on behalf of people who are not in the room. It makes decisions now that others must trust later. It turns private judgement into public consequence. Every system reflects what its makers valued, what they ignored, what they measured, and what they allowed to become automatic. In the age of AI, our systems will learn from us. They will absorb our language, incentives, shortcuts, assumptions, and silences. They will become mirrors with agency. If we are careless, they will scale carelessness. If we are clear, they may scale clarity. If we build with humility, they may help us create systems that remember who they serve.
That is the promise now: engineers must rise to the level of the systems they have created, treating intent not as a prelude to implementation but as the central artefact of the discipline. In the age of hardware, the promise was strength. In the age of software, the promise was behaviour. In the age of platforms, the promise was flow. In the age of intent, the promise is alignment. Alignment is not a feature. It is a discipline. It is the daily practice of keeping action faithful to purpose, even when action is automated, accelerated, and distributed across intelligences we may never fully see.
So yes, improve the coding agents. Of course. But do not confuse the optimisation of implementation with the future of engineering. The frontier is not the agent that writes the code. The frontier is the system that knows what the code is for. Because the question at the end of this Golden Age of Software Engineering is not whether we can build. We can. The question is whether what we build will remember what it was for.
Like this article? Join the update list.