Is English really the hottest programming language? Karpathy's 2023 tweet, three years later

TL;DR — 2023 tweet vs 2026 reality

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:

1. GPT-3 paper (Brown et al., 2020) — models learn tasks from input:output examples in the prompt without weight updates ("in-context learning").
2. Chain-of-thought (Wei et al., 2022) and Zero-shot CoT (Kojima et al., 2022) — the prompt can program solution strategy, not just task format.
3. Ev Jang on generalization and Mishra et al., 2021 — good prompts include desired performance; models imitate; you must ask for success explicitly.
4. Building a Virtual Machine inside ChatGPT — English rules and I/O specs condition the model into a role (a VM, a parser, a state machine).
5. ChatGPT HomeKit voice assistant (Medium, 2023) — a personalized voice stack programmed in English, not Swift.

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:

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.
• Ask for success. Models imitate tone and format; you must specify the performance bar (Karpathy-aligned Claude Code habits encode this).
• 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:

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 (July 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 July 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.

Further reading: What is vibe coding? · How to learn AI · Karpathy Claude Code guidelines