The Future of Programming Languages
in the Age of AI

The most dramatic prediction about AI and programming languages, that LLMs will replace programmers and render traditional coding skills irrelevant, has not materialised and shows no sign of doing so. What has materialised is something subtler: AI has changed the developer workflow, raised the floor on programmer productivity, and created new demand for certain skills while reducing demand for others.

Understanding what is actually happening, as opposed to what is predicted by commentators without programming experience, requires looking at the evidence from developer surveys, adoption data, and the technical constraints that AI coding tools operate within.

AI-assisted coding: what the data shows

GitHub Copilot, launched in 2021, was the first widely adopted AI coding assistant. In a controlled study, GitHub found developers using Copilot completed a well-specified task 55% faster than those without it.^[1] Adoption has since gone mainstream: Copilot grew from around 1.3 million paid users in early 2024 to more than 20 million users by late 2025.^[6]

The Stack Overflow Developer Survey 2024 found that 76% of developers use or plan to use AI tools in their workflow (up from 70% in 2023), with 62% actively using them — a jump from 44% a year earlier.^[2] By the 2025 survey that had climbed to 84% using or planning to use AI tools; yet trust moved the other way. The share of developers who trust AI output for accuracy fell to 29% (from 40% in 2024), and 66% reported spending more time than expected fixing AI-generated code that is "almost right, but not quite."^[7] The most common uses remain code completion, generating boilerplate, explaining unfamiliar code, and writing tests.

The productivity gains are concentrated in specific tasks. AI tools excel at: generating syntactically correct implementations of well-understood patterns (sorting algorithms, CRUD operations, unit test scaffolding), translating code between languages, explaining code, and completing code given a clear surrounding context. They struggle with: novel architectural decisions, debugging subtle logic errors, maintaining consistency across large codebases, and understanding the business context that determines what code should actually do.

The practical implication: AI tools are most valuable to developers who already understand the code being generated, because they can evaluate correctness, and least valuable (and most dangerous) to developers who cannot recognise when generated code is subtly wrong. This inverts the intuition that AI tools help beginners most.

How AI changes the skill profile

If AI handles more of the mechanical code generation, what do developers spend their time on? The emerging answer from teams using AI coding tools heavily is: requirements analysis, architecture, code review, debugging, testing, and communication. These are the skills that remained expensive before AI tools and remain expensive after, because they require understanding business context, user needs, and system behaviour at a level that current AI cannot match.

The skills that AI tools reduce the demand for are: writing repetitive boilerplate, implementing well-specified standard algorithms, and producing syntactically correct code for familiar patterns. These were never the high-value activities in software development; they were the low-value activities that consumed time needed for high-value ones. Automating them is productivity improvement, not role replacement.

Research by MIT economists Brynjolfsson and Li (2023) studying GitHub Copilot adoption in a professional software company found productivity gains of 26% for experienced developers and 39% for less experienced ones, but also found that the nature of work shifted toward higher-level tasks rather than disappearing.^[3]

Natural language as a programming interface

The most structurally significant development is the emergence of natural language as a programming interface. LLMs can accept natural language descriptions of intended behaviour and produce code that implements them. This is a new layer in the abstraction stack, above existing high-level languages, not replacing them.

The code produced by LLMs is code in existing languages: Python, TypeScript, SQL, Rust. It runs on existing runtimes, is evaluated by existing compilers, and must meet the same correctness standards as hand-written code. Natural language is the specification layer; existing languages remain the implementation layer. This is the same relationship that pseudocode has always had to real code, but now the translation from specification to implementation is partially automated.

This does not diminish the importance of understanding the target language. A developer who cannot read Python cannot evaluate whether an LLM's Python output is correct. The ability to specify intent in natural language and evaluate the generated implementation requires deep language knowledge, it just shifts where that knowledge is applied.

Domain-specific languages (DSLs) and their resurgence

A domain-specific language is a language designed for a particular problem domain rather than general computation, SQL for database queries, HTML/CSS for web documents, regular expressions for text pattern matching, Terraform for infrastructure configuration, GraphQL for API queries.

AI tools are particularly effective at generating DSL code. SQL generation from natural language questions about data (text-to-SQL) achieves high accuracy on well-structured databases. Terraform configuration generation, CSS generation from design descriptions, and regex generation from pattern descriptions are all mature capabilities of current LLMs.

This is accelerating DSL adoption: as the friction of learning a DSL decreases (because AI can generate it from natural language), more problem domains are encoded in purpose-built languages rather than general-purpose ones. Infrastructure-as-code, configuration languages, and workflow definition languages are all expanding.

Memory safety at scale: Rust, the Linux kernel, and national security

One of the clearest trends in programming language adoption, unrelated to AI, is the coordinated push toward memory-safe languages for security-critical systems. The US Cybersecurity and Infrastructure Security Agency (CISA) published guidance in 2023 urging organisations to migrate away from C and C++ toward memory-safe languages for new development, citing memory safety bugs as the dominant source of exploitable vulnerabilities.^[4]

This institutional push (backed by the NSA, CISA, and equivalent agencies in the UK, Australia, and Canada) is already influencing language adoption decisions in government contractors, critical infrastructure operators, and large technology companies. Rust, Go, Swift, and Kotlin are the primary beneficiaries.

Nowhere is that shift more concrete than in the Linux kernel. Rust support landed in mainline in kernel 6.1 (2022) as an explicit experiment; by 2025, kernel maintainers formally declared the experiment a success — Rust is no longer experimental but a permanent part of the kernel.^[8] Real, memory-safe drivers have followed: the Rust-based Android Binder driver was merged for kernel 6.18, and Rust GPU drivers such as Nova (for NVIDIA hardware) are landing in mainline — putting Rust kernel code into shipping devices, not just prototypes. It is a useful reminder that the most consequential language shifts of this era are being driven by security, not by AI.

What does not change

Through all these shifts, several things remain stable:

• The need for precision. Computers execute exactly what code says, not what the programmer meant. AI tools reduce the cost of writing correct code; they do not eliminate the need for correctness. Debugging, testing, and verification remain essential.
• The primacy of algorithms and data structures. The fundamental concepts that determine whether a program is efficient (time complexity, space complexity, appropriate data structure selection) are not automated by AI tools. A Copilot-generated sorting algorithm that is O(n²) on a million-element dataset is still O(n²).
• The value of understanding the full stack. AI tools generate code. Developers who understand what the generated code does (at the language level, the runtime level, the system level) can evaluate, debug, and extend it. Developers who treat generated code as a black box are at the mercy of its errors.

"Every new tool that automates part of programming raises the abstraction level of what programmers do — and creates demand for programmers who can work at that higher level. This has been true from assembly to compilers, from compilers to frameworks, and it is true from frameworks to AI."

— Erik Brynjolfsson & Andrew McAfee, The Second Machine Age, W. W. Norton, 2014

The languages most likely to gain in the AI era

Based on current trajectories: Python's position in AI/ML is structurally secure for the medium term. Rust will continue growing as memory safety requirements propagate through the industry. TypeScript will consolidate as the professional JavaScript standard. Go will remain dominant in cloud infrastructure. The emergence of purpose-built AI inference languages (Mojo, developed by Modular, combines Python syntax with C-level performance for ML workloads) represents a genuine bet on a new niche that did not exist five years ago.^[5]

Related reading

• The Evolution of Programming Languages — how we got here.
• Python vs JavaScript in 2026 — the languages AI leans on.
• What Makes a Programming Language Successful? — what AI changes about adoption.