The arrival of higher-level languages, low-code platforms, cloud computing, and now artificial intelligence have all been framed as moments where “programmers” would become obsolete. And yet, code has not only survived each transition, it has become more valuable, more central, and more powerful.

If we look back across the relatively short history of computing, it becomes clear that the “value” of code has never been fixed. It has shifted repeatedly, sometimes dramatically, based on what technology made possible, what businesses needed, and what skills were available to craft it.

Today, with AI systems capable of generating code in seconds, we are facing another major shift. In the AI era, the question is not whether AI will replace developers, that framing misses the point, but what the value of code becomes when it can be created and recreated in seconds using natural language.

In the earliest days of computing, code did not exist as we recognise it today. Programs were created by physically reconfiguring machines: plugging cables into different sockets, flipping switches, adjusting dials, or rewiring entire panels. Instructions were embodied in hardware. To change a program meant to change the machine itself.

Only a small number of highly trained engineers could operate these machines, and the cost of change was enormous. Computation was slow to adapt, but when it worked, it delivered something unprecedented: repeatable, reliable calculation at a scale humans could not achieve, for high-stakes problems including artillery trajectories, cryptography (code breaking), and scientific calculations (nuclear physics).

The value of code at this stage was precision and control. It delivered exact, repeatable outcomes, but only in the hands of a small, highly specialised group.

The next major leap came with machine code and assembly languages. Instead of rewiring hardware, engineers could type symbolic instructions that mapped directly to processor operations. This was still deeply technical work, but it represented a fundamental shift: humans no longer had to physically alter machines to change behaviour. Code became an abstraction layer between human intent and machine execution.

As higher-level languages emerged, FORTRAN, COBOL, Lisp, C, the gap between human thinking and machine instruction narrowed further.

Changes could be made faster. Software could evolve without rebuilding hardware. Entire industries formed around the idea that behaviour could be changed by editing text.

The value of code in this era was accessibility. More people could program, and behaviour could be changed without rebuilding machines. Code stopped being a mechanical artefact and became a way for humans to express logic.

As software systems grew in complexity, the challenge shifted again. Writing instructions wasn’t enough; engineers needed ways to model reality. This gave rise to structured programming, object-oriented design, domain modelling, and architectural patterns. Code became less about telling machines what to do and more about describing how the world works.

A banking system wasn’t just loops and conditional logic, it was accounts, transactions, rules, risk models, and regulatory constraints. The code explained the domain, in a language humans could understand, and compilers translated this human language into machine instructions.

Code became a shared language between business intent and technical execution. Done well, it allowed organisations to scale operations, standardise decisions, and embed expertise directly into systems.

The value of code here was alignment and shared understanding. Code became the place where business intent, domain knowledge, and technical execution met, and where software engineering emerged as a discipline, not just a skill.

As digital systems became central to business operations, organisations realised something crucial: code wasn’t just supporting the business, it was the business.

Faster systems meant faster decisions. Better algorithms meant better pricing, logistics, recommendations, and risk management. Software stopped being a cost centre and became a strategic weapon. Companies that could write better code, faster, gained disproportionate advantage. They entered markets earlier, scaled more efficiently, and responded to change more quickly than competitors burdened by manual processes or rigid systems.

The value of code at this stage was differentiation. Organisations that could change behaviour faster than competitors turned software into a strategic weapon. Engineering teams moved from the back office to the boardroom.

This shift laid the foundations for the next transformation.

Over the last two decades, software companies have become the most valuable organisations on the planet.

Technology giants don’t primarily sell physical products, they sell platforms, ecosystems, and digital services. Their marginal cost of replication is close to zero, while their reach is global.

Globalisation and cloud computing accelerated this dramatically. Infrastructure that once took years and millions to build could now be provisioned in minutes. Startups could operate at a global scale from day one. Entire industries were disrupted by organisations whose primary asset was code.

The value of code here was leverage. A small number of engineers could create systems used by hundreds of millions of people. Software compressed time, space, and organisational boundaries. It’s no coincidence that computer engineers became some of the highest-paid professionals in the world. Their work directly translated into scalable value creation.

Now we arrive at the current moment, and once again, the obituary for code is being written.

AI systems can generate code in seconds from natural language prompts. Entire applications can be scaffolded, refactored, or rewritten almost instantly. The mechanics of writing code are becoming cheaper, faster, and increasingly automated.

At first glance, this seems like a direct threat to software engineering as a profession.

But history suggests otherwise.

Every time the mechanics of coding have become easier, the value of code has shifted, not disappeared.

In an AI era, the value of code moves away from syntax and implementation detail and towards intent, constraints, and outcomes.

If code can be created and recreated instantly, then the scarce skill is no longer typing correct instructions, it is knowing what should exist in the first place.

Software engineering roles will not vanish; they will be reimagined. Engineers will spend less time translating ideas into code and more time shaping systems:

• Defining boundaries and constraints
• Establishing architectural direction
• Evaluating trade-offs
• Governing safety, security, and ethics
• Integrating systems into messy real-world contexts

AI may write the code, but humans still decide what the system should do, and why.

One provocative implication of AI-generated software is this: we may no longer need code that humans can easily read.

For decades, readability has been a core principle of software engineering because humans needed to maintain and evolve systems. But if AI systems can understand, modify, optimise, and regenerate machine-level representations directly, then human-interpretable code becomes optional.

We may see a future where systems are represented in forms optimised for machines, not people, continuously regenerated, verified by other machines, and deployed without traditional source files.

In that world, the value of code is not its readability but its correctness, performance, and alignment with intent.

Humans won’t read the code; they will interrogate behaviour.

There is one challenge that has persisted throughout the entire history of software, and AI does not eliminate it.

Specifying what you actually want.

It has always been difficult to articulate requirements clearly enough for engineers to build the right thing. Misunderstandings between stakeholders and developers are legendary. Entire methodologies exist to manage this gap, and still it remains the primary source of failure. Agile didn’t emerge because we are lazy and didn’t want to specify a system up-front, it emerged because humans have great difficulty in defining a system up-front without being able to visualise and refine.

In an AI era, this problem becomes even more central.

If you can generate code instantly, then poor requirements don’t slow you down, they accelerate you in the wrong direction.

The true bottleneck becomes sense-making: understanding needs, context, constraints, values, and trade-offs. The ability to express intent precisely, test assumptions quickly, and refine outcomes continuously becomes the most valuable skill of all.

The focus shifts from building the thing right to building the right thing.

So what is the value of code in an AI era?

Code becomes:

• A transient artefact, not a permanent asset
• A means to an end, not the end itself
• A reflection of intent rather than a handcrafted object

The value of code now lies in operationalising intent, in how clearly it captures understanding, how safely it enables change, and how effectively it turns human goals into system behaviour.

The organisations that succeed will not be those that write the most code, but those that are best at deciding what should exist, why it should exist, and how it should evolve.

Just as every previous shift increased the strategic importance of software, this one will too, but for different reasons.

The era of code is not ending.

It is maturing.

And as always, the value moves up the stack, from hardware, to syntax, to models, to intent.

In an AI era, code is no longer the scarce resource.

Clarity of intent is.

Those who recognise that shift won’t be replaced by AI.

They’ll be amplified by it.