Is English really the hottest programming language? Karpathy's 2023 tweet, three years later
Andrej Karpathy said "The hottest new programming language is English" in January 2023. In 2026, with Claude Code, Cursor, and agent loops, here's what that prediction got right, what changed, and what still requires real code.
On January 25, 2023, Andrej Karpathy posted a line that would hit 12.8 million views:
The hottest new programming language is English.
It was not a joke about Americans. It was a compression of something researchers were already seeing: large language models behave like interpreters whose "source code" is natural language.
Three years later — after Copilot inside IDEs, ChatGPT plugins, Claude Code, Cursor agents, MCP, and Karpathy's own vibe coding coinage — the tweet reads less like hype and more like a release note for an unfinished compiler.
This post is the 2026 perspective: what Karpathy was pointing at, what his follow-up thread actually cited, and what programming in English looks like when the prompt is no longer trapped in a chat window.
What the tweet actually claimed
Karpathy did not say Python was dead. He said a new layer of abstraction had appeared — one where you specify behavior in English and the model executes it inside the context window.
A month later, he posted a thread linking the intellectual lineage:
GPT-3 paper (Brown et al., 2020) — models learn tasks from input:output examples in the prompt without weight updates ("in-context learning").
Read together, the thread's thesis is precise: English is not replacing C. English is the bytecode humans write for a new kind of machine — one that generalizes from instructions in the prompt.
That was radical in 2023. In 2026, it is table stakes.
The 2023 version: REPL without a repo
In early 2023, "programming in English" mostly meant:
Paste examples → get classifications or transformations
Write rules in prose → get structured outputs
Chain prompts → simulate multi-step pipelines
Copy generated snippets → paste into your real project manually
The virtual machine posts were the clearest metaphor: you declare states, transitions, and formats in English; GPT plays the machine for one session. Powerful — and ephemeral. Close the tab, lose the program unless you saved the prompt.
Developers who lived through that era remember the friction: great codegen, terrible integration. The model did not know your imports, your folder layout, or your failing test. English was the language; the deployment target was still your fingers.
What changed by 2026: agents as the runtime
The tweet aged well because the missing runtime arrived.
English is still the source language. But the "compiler" is now an agent loop: read intent → edit files → run commands → observe errors → revise.
Karpathy made that cultural shift explicit when he named vibe coding in 2025 — describe the vibe, review output, iterate. Same lineage as the 2023 tweet; production-grade harness instead of a chat REPL.
Programming in English today: three concrete patterns
1. Prompt as spec (still valid)
You are defining behavior in natural language:
snippet
When the user uploads a CSV:
- Validate headers against SCHEMA.md
- Reject rows with empty email
- Return a summary: row count, error count, first 3 errors
In 2023, this lived in ChatGPT. In 2026, it lives in CLAUDE.md, agent skills, or issue templates — version-controlled English that every session inherits. That is software configuration by prose.
2. Prompt as program (Karpathy's VM idea, industrialized)
The engraved.blog VM pattern scaled up: rules + state + I/O in English, but now backed by:
File system state (not imaginary registers)
Tool calls with real side effects
Tests that fail when the "program" drifts
Example: an agent that only merges PRs when lint and typecheck pass is policy written in English, enforced by tools. The LLM is the interpreter; CI is the type checker.
3. Prompt as product (the HomeKit assistant, generalized)
The 2023 HomeKit shortcut was a vertical app defined in prompts. In 2026, non-developers ship the same class of thing with vibe coding tools — booking flows, internal dashboards, newsletter automations — without maintaining a main.py.
The constraint moved from "can the model do it once?" to "can you evaluate and maintain it?"
What Karpathy got right — and what people misread
Right
In-context learning is programming. Examples and instructions in the prompt are the program for that inference.
Strategy is programmable. Chain-of-thought and decomposition belong in the spec, not just the task label.
English lowers the floor. More people can author behavior without memorizing syntax.
Misread
"I don't need to learn code." You need code literacy — read diffs, debug failures, know when the agent hallucinated an API. Our learn-AI roadmap separates using AI (Stages 1–4) from shipping with agents (5–6) from real engineering (7).
"English replaces formal methods." It does not. Ambiguous prose → ambiguous software. Tests, schemas, and review are the static analysis English lacks.
"One prompt = one product." Products need state, auth, migrations, observability. English bootstraps; engineering sustains.
The vibe coding nightmares post exists because the misreads became expensive in 2025–2026.
English vs Python: a useful analogy
Think of the stack like this:
snippet
English intent → Agent / IDE → Python/TS/Rust files → CPU
↑ ↑ ↑
"source" "compiler" "object code"
Karpathy's 2023 insight: the top arrow became productive.
2026 addendum: the middle box matters as much as the top. A sloppy compiler (weak agent, no repo context, no tests) produces sloppy object code — fast.
That is why "English programming" in production looks like:
Clear specs in markdown
Small, reviewable diffs
Automated checks on every loop
Human judgment on architecture and security
Not infinite chat.
Who should care in 2026
Beginners: English is the on-ramp. Start with prompts and structured tasks (terminal basics, first Cursor project), then add agent tools when copy-paste breaks down.
Working developers: English is the interface layer for boilerplate, refactors, and exploration — not a license to skip design. The job shifts toward specification, review, and integration.
Teams: Treat prompts like code: review CLAUDE.md, version skills, lint agent outputs, document agent memory patterns so context survives sessions.
Leaders: Karpathy's line is a hiring signal. Value people who can translate business intent into testable English specs and who know when to override the model.
The honest ceiling (June 2026)
English-as-language works best when:
Feedback loops are fast (tests, linters, preview deploys)
Scope is bounded (one service, one app, one script)
Failure is cheap (internal tool, MVP, prototype)
It strains when:
Correctness must be provable (payments, safety, compliance)
Systems span many teams and years of legacy
Adversaries target your stack (prompt injection, tool abuse)
No amount of eloquent prose fixes wrong architecture. The tweet was about a new interface, not the end of computer science.
Bottom line
Karpathy's January 2023 line was early, not wrong: the highest-leverage "syntax" for many programming tasks is now natural language.
By June 2026, the picture is sharper:
English = how you author intent
Agents = how intent becomes edits and commands
Repos + tests = how intent becomes reliable software
The hottest programming language is still English — but only if you treat everything below the prompt as engineering.
If you are starting today, do not memorize Python on day one. Do learn to write precise instructions, read what the agent changed, and run one command that proves it works. That is programming in 2026 — and it is exactly what that 12.8M-view tweet was pointing at.
