Is Coding Dead? How AI Is Changing the Future of Programming

How coding is  evolving into a higher-level discipline where developers focus on designing, guiding, and validating AI-driven systems rather than just writing code.

A question I get asked often is whether this is the end of coding.

The first time I heard it was in the 1980s, when a low-level programmer working in assembly argued that higher-level languages and compilers would mark the end of efficient programming. Developers using those tools, he claimed, simply did not know how to code.

Versions of this argument have repeated ever since. FORTRAN versus Pascal. C versus Java. Java versus no-code. And now, Python versus AI coding agents.

The pattern is familiar. Each shift raises concerns about whether abstraction reduces the need for real programming skill.

AI Is Changing How Code Is Written

What is different now is the scale.

AI tools are now used by 84% of developers, and many organizations – such as our own – track how much of their code is generated by AI. In our case, that number exceeds 30%.

This echoes earlier transitions. At the time, similar attention was given to how much code was effectively written by compilers. For example, moving from assembly to FORTRAN reduced the number of lines needed for the same program by as much as 65–95%.

At the same time, the market sends mixed signals. Entry-level developers are finding it harder to get hired, while overall demand for software developers is expected to grow. Universities are starting to question whether traditional coding curricula will remain relevant.

Taken together, these trends make the question feel more urgent. But they still do not point to the end of coding.

The Role of the Programmer Is Shifting

What is changing is not whether we need programmers, but what we need them to do.

Coding is becoming more collaborative, with AI handling an increasing share of implementation. But this does not reduce the importance of developers. I would argue that coders are playing an increasingly significant role that is not quantified by lines of code.

This creates a growing need for developers who can interpret, validate, and refine AI-generated outputs, especially since such code often requires rework. The measure of a programmer is no longer how many lines they write, but how effectively they shape and control the system.

This shift makes more sense when you step back and look at what programming has always been.

Programming has never really been about rigid syntax or knowing how to compile and run code. At its core, it is about expressing intent in a structured, extensible, and reusable way.

Languages like Prolog, developed in the 1970s, made this explicit. Prolog is built on logic predicates and declarative statements, which shifts the focus from writing step-by-step solutions to clearly defining the problem itself. When the problem is specified unambiguously and the relevant facts are provided, the system determines how to solve it. The result is code that behaves as intended without explicitly coding the procedure.

This way of thinking is different, but closely parallels how we design and prompt agentic systems today.

Expressing intent can take a similarly declarative form, where the problem is outlined and the underlying LLMs determine how to solve it. At the same time, complete autonomy is not always sufficient. In many cases, we need to guide the solution by defining steps, constraints, and the expected logical progression.

In other words, the medium may be natural language, but the requirement remains the same: we still need to think algorithmically.

Natural Language Introduces New Challenges

There is a reason, beyond the difficulty of parsing it, that traditional programming languages were designed to be context-free and syntactically rigid. Natural language is inherently ambiguous and relies heavily on context and interpretation. That is what makes it expressive, but also what makes it difficult to translate into repeatable, deterministic machine behavior.

We can now express algorithms in natural language because LLMs can interpret it. But that also means LLMs can be confused in the same way humans are. The intent behind a prompt is not always clear, and that ambiguity becomes a source of inconsistency.

At the same time, this shift does not reduce the need for programming skill. A good AI programmer today still needs to be a strong algorithmic thinker and more. Foundational software concepts such as architecture, system design, modularity, abstraction, reusability, and resilience are more relevant than ever.

While coders will be spending less time on repetitive tasks, we are now in an agent-oriented world where each module has a mind of its own. This changes the nature of the work, so an AI coder today will need to additionally have skills analogous to what is taught in management school. For the first time, social sciences will be a required course for programmers, as they will be building and managing societies of agents.

As Andrej Karpathy states, software engineers will become “Agent Engineers” – people who design agentic systems, orchestrate agents, define workflows, and govern systems. While AI is a leveler and more non-coders are increasingly able to map their intent and imagination to concrete apps and prototypes, the expertise will shift and elevate to safeguarding, interconnecting, and engineering at a higher, agentic level.

AI will continue to improve at many of these tasks, but it lacks lived experience. The gap between what is prebuilt into AI systems and what is required for a specific use case still needs to be defined, prioritized, and implemented by human developers.

The Gap Between Anyone Who Can Code and Those Who Can Build Reliable Systems

In the past, the distinction between a coder and a non-coder was clear. Non-coders could not build software, while coders varied in skill from novice to expert. Today, everyone can “code” AI. All you need is the ability to express your intent in your own language, and so, at first sight, the distinction between a coder and a non-coder of AI is not as obvious. There is, however, a significant difference between someone who knows the capabilities, limitations, safety aspects, and algorithmic and structural requirements of an AI system and someone who does not. When comparing the resulting AI systems built by the novice versus expert AI coder, it will be clear which one we can trust more.

As long as we want to remain in control of the systems we build, we will need to know how to code, even if we no longer implement every component ourselves. This is not new. Far from disappearing, coding is evolving. New roles are emerging that require AI-focused development skills, including AI code auditors, intent designers, system architects, AI supervisors, and verification engineers. These are likely to be some of the most important roles going forward.