May 23, 2026 · Analysis
The Future of Programming with AI — What Actually Changes
Five shifts already visible in the data, and the languages that benefit from each.
Most of what gets written about AI and programming is forecast about what might happen in three years. The interesting question is the narrower one: what has already happened and is visible in the data?
We track 20 languages across 7 data sources at LangPop (see methodology). Below are five shifts the index makes visible — none of them speculative, all of them slow, all of them more important than the rankings themselves.
1. Reading code becomes the bottleneck
For decades the limiting factor on a working day was how fast you could write the next 50 lines. With Copilot, Cursor, and Claude Code producing a working first draft in seconds, the new bottleneck is reviewing it. GitHub's published acceptance-rate data has hovered around 30% — meaning developers spend most of their AI-assisted time deciding what to keep, not what to type. That changes which language properties actually matter. Languages that produce code humans can scan quickly — explicit types, consistent conventions, low overloading, predictable control flow — win. Languages that reward terseness and cleverness lose.
2. Static types become a productivity feature, not a discipline tax
Stack Overflow's developer survey has shown TypeScript climbing for nine consecutive years, and the LangPop index has it consistently in the top four (see /rankings). Part of that is browser dominance. But a growing part is that AI-generated code with types is verifiable in the IDE before you run it. The compiler catches the model's hallucinated method names. The same dynamic favours Rust over C, Kotlin over Java in greenfield JVM work, and Pydantic-everything over loose Python. The decade-long swing toward dynamic languages — the Ruby/Python era from 2005–2018 — is structurally reversing, and AI is what reversed it.
3. Glue languages get squeezed; systems languages get more interesting
Two things are happening at once. At the top of the stack, the work that small-to-medium scripts and glue code used to do — fetch this, transform that, post the result — is increasingly produced by an LLM in a single prompt. There is less need for a human to keep a long-running mental model of a 200-line script when the model writes it on demand. At the bottom of the stack, the opposite: the hot loops that handle inference, vector search, transformer training kernels, and database engines remain places where small constant factors matter and where the AI is more useful as an assistant than as the author. The result: Bash, Perl, and "personal Python" lose ground; Rust, Zig, C++, and Mojo gain meaning even though their raw rankings shift slowly.
4. The "documentation moat" becomes load-bearing
Models are good at languages with enormous public corpora and bad at languages without them. Python, JavaScript, and Java are over-represented in training data by orders of magnitude. Newer or smaller-community languages — Gleam, Roc, Nim, even Zig — produce noticeably worse first drafts from frontier models, and that asymmetry compounds. The languages with the most documentation, the most Stack Overflow Q&A, and the most public GitHub code get an additional flywheel: developers reach for them because the AI is better at them, which produces more code in those languages, which trains better models on them. Smaller languages are not killed by this — they keep their committed user bases — but the gravitational pull on undecided developers gets stronger.
5. Notebooks and "agentic" code get a real category
Until 2023, "AI-assisted code" mostly meant autocomplete on a function. By 2026 it means an agent that opens files, runs tests, edits across the codebase, and commits a PR. The shape of that workflow rewards languages and tools with strong tooling APIs, deterministic build outputs, and clean error messages. TypeScript with its language server, Rust with cargo, Go with its straightforward toolchain, and Python with uv/ruff are well-positioned. Languages with weaker tooling stories — older PHP codebases, Ruby with its less-deterministic Bundler dynamics, plain C with no canonical build system — feel friction the others do not. This is the quiet reason "developer experience" stopped being a soft selling point and became a primary axis on which languages are evaluated.
Where the asymmetry lands
The five shifts above are not symmetric. They produce winners and losers, and the gap between them widens as AI tooling improves. Worth naming explicitly:
Structurally favoured
Typed mainstream (TypeScript, Kotlin, Swift)
Types let the model and the human verify the same draft. Massive training corpora. Strong IDEs.
Rust
Hot-loop language for inference + tooling. Tight ecosystem. The borrow checker is exactly the kind of verifier an LLM benefits from working with.
Python — for what it remains the universal API for
Not the personal-script Python that loses ground, but the Python that wraps numerical libraries, ML frameworks, and data pipelines. PyTorch, NumPy, Pandas, Pydantic.
Go
Boring on purpose. Generates extremely readable AI output. Strong tooling. Fast cold-start for serverless and agent workflows.
New systems languages (Mojo, Zig)
Bet on the AI-era kernel layer. Not yet in the top 20, but the structural argument is real.
Structurally squeezed
Languages without good tooling APIs
Agents work where they can introspect — language servers, type info, deterministic builds. Languages without these get skipped.
Languages that reward terseness
Perl, golf-style Ruby, point-free Haskell. AI-generated terse code is hard to review, which negates the productivity win.
Languages with thin documentation
Smaller-corpus languages get worse first drafts. The gap to mainstream languages widens, not narrows.
Personal-script Python
Loose, untyped, no tests, kept-in-the-head Python is the exact thing an LLM can rewrite from a sentence. The work it used to do is collapsing into prompts.
What this means if you are choosing a language to learn
The advice that worked in 2018 — “learn Python, you can do anything with it” — is still mostly right, but for a narrower set of reasons. Python remains the universal glue language for the AI stack itself; if you want to work on or with ML, you cannot avoid it. But if your goal is web work, you should learn TypeScript before Python now, not after. If you want to work on infrastructure, Rust and Go are stronger bets than they were five years ago. If you want to be the person who writes the next-decade kernel layer for inference, learn enough C++ to read it and enough Mojo or Triton to participate in what comes next.
The least valuable thing you can be in 2026 is a fluent typist of unmemorable intermediate code. The most valuable thing you can be is the person who can review a draft an LLM produced in 8 seconds and know — without running it — what is going to break. That skill is not language-specific. It is closer to taste than to knowledge.
What this means for the rankings
We update the LangPop composite every Tuesday. Watch four signals over the next 12–18 months:
- •TypeScript's gap to JavaScript — they are not converging. TS keeps climbing because typed code is verifiable by both humans and models.
- •Rust's rate of climb in job postings — the leading indicator for systems work moving to memory-safe languages.
- •Stack Overflow question volume — already down by more than half year-on-year. The decline is itself a measurement of where the work is moving.
- •Whether Mojo or Bend make it onto the index — they are not in the top 20 today. If either crosses that line, it is a real signal about kernel-layer re-architecture.