Andrej Karpathy’s remark that “the hottest new programming language is English” has become one of the defining observations of the LLM era. I believe it is only half the story. The more interesting question is not whether English is becoming a programming language, but what kind of programming language it is. This article argues that prompts should no longer be viewed as mere instructions with a few constraints attached. They are executable programs for a probabilistic reasoning engine. Once viewed through that lens, familiar concepts such as functions, variables, loops, conditions, and modular design emerge naturally, and decades of software engineering experience suddenly become applicable to prompt engineering. The result is a shift from writing prompts to designing reasoning programs.

Most people think of prompting as “giving instructions to an AI.” That’s a useful mental model, but it’s also limiting. A more powerful way to think about prompting is this:

A prompt is not just an instruction. It is a program executed by a probabilistic interpreter.

The “interpreter” happens to be a large language model instead of a CPU. The language is natural language instead of C or Python. But many of the concepts from programming still apply.

From instructions to programs

A typical prompt looks like this:

Summarize the following text in three bullet points.

This is analogous to calling a function:

summarize(text, bullets=3)

Nothing remarkable here. But modern LLMs can execute much richer “programs.”

For example:

Analyze the document.
If it is a technical specification:
extract requirements.
Otherwise if it is source code:
identify architecture.
Otherwise:
explain what kind of document it is.
Repeat until all sections have been analyzed.
Finally create a summary.

This is no longer a simple instruction. It contains

  • branching
  • iteration
  • state
  • multiple execution phases

In other words, it behaves like a small program.

Control flow already exists

Most programming languages consist of only a few fundamental ideas:

  • sequential execution
  • conditions
  • loops
  • variables
  • functions
  • exceptions

Surprisingly, LLMs understand nearly all of these when expressed in natural language.

Sequential execution

  1. Read the document.
  2. Extract all requirements.
  3. Group similar requirements.
  4. Produce a traceability matrix.

The model naturally performs these steps in order.

Conditional execution

If no requirements are found,
stop and explain why.
Otherwise continue with classification.

This is an ordinary if statement.

Multi-way branching

If the log contains crashes,
perform crash analysis.
Else if it contains timeout errors,
analyze timing.
Else if it contains network errors,
analyze communication.
Otherwise produce a general diagnosis.

This resembles a switch statement.

Loops are possible — even without explicit syntax

Many people assume prompting has no loops. Actually, iterative behavior is easy to express. For example:

Search for inconsistencies.
Whenever you find one,
record it.
Continue searching until the entire document has been analyzed.
Or:
Repeat the following process:
- identify the largest remaining issue
- explain it
- remove it from consideration
Stop when no issues remain.

This is essentially a while loop.

Variables exist, but differently

Traditional programs store variables in memory. Prompts instead use working memory described in language. For example:

Maintain a list called Findings.
Whenever you discover a defect,
append it to Findings.
Use Findings in the final report.

The variable exists conceptually rather than as a memory address. The LLM tracks it throughout its reasoning.

Functions are surprisingly natural

You can define reusable procedures.

Whenever I say "perform security review",
execute the following steps:
1. Search for authentication issues.
2. Search for authorization issues.
3. Search for data leakage.
4. Estimate severity.

Later:

Perform security review.

You have effectively defined a function. Prompt libraries are increasingly built around such reusable patterns.

Higher-order functions

Even abstraction is possible.

For every issue you discover,
apply the following evaluation procedure:
- estimate likelihood
- estimate impact
- estimate confidence
Return the result.

This resembles:

issues.map(evaluate)

Recursive prompting

Recursion is possible too.

Break the problem into smaller problems.
For each subproblem,
solve it using exactly the same procedure.
Continue until the remaining problems cannot be subdivided.

This is recursive decomposition expressed in English.

State machines

A prompt can even define state transitions.

The system can be in one of four states:
Idle
Learning
Testing
Finished
Describe transitions according to the observed events.

The model maintains state while processing.

Prompt programs become surprisingly sophisticated

Imagine analyzing automotive test logs. Instead of writing:

Analyze this logfile.

You write:

Initialize:
Create
- Errors
- Warnings
- Unknown events
For every log entry:
If it matches a known failure pattern:
classify it.
Otherwise if confidence is below 70%:
place into Unknown events.
Otherwise:
classify normally.
After each 500 lines:
Review accumulated evidence.
Merge duplicate findings.
At the end:
Rank findings by probability.
Generate hypotheses.
Suggest additional tests that would distinguish between the remaining hypotheses.
Repeat hypothesis refinement until no further evidence can be extracted.

This is already much closer to a domain-specific language (DSL) than to a casual instruction. The prompt encodes workflow, decision logic, intermediate state, and stopping criteria.

Prompting is becoming declarative programming

Interestingly, prompts often describe what should happen rather than how every step should be implemented. That resembles SQL.

Find every contradiction.
Group related contradictions.
Explain the root cause.

You specify the desired result. The LLM determines the implementation.

The model acts as both interpreter and optimizer

A CPU executes instructions literally. An LLM does something closer to:

  1. understand intent
  2. plan execution
  3. infer missing details
  4. optimize intermediate reasoning
  5. generate output

This resembles a compiler combined with an execution engine. That is why prompts can be much shorter than equivalent conventional programs.

Where the analogy breaks down

Prompt programming is powerful, but it differs fundamentally from traditional programming:

  • Probabilistic execution: The same prompt may produce slightly different outputs across runs, especially at higher sampling temperatures.
  • Implicit state: Variables are represented through the evolving conversation or generated text rather than fixed memory locations.
  • No guaranteed control flow: An LLM can misunderstand or partially skip an instruction unless the prompt is structured to reinforce the intended workflow.
  • Soft semantics: Terms such as “important,” “similar,” or “likely” are interpreted rather than rigidly defined.
  • Limited persistence: Long-running loops are constrained by the model’s context window and token budget, unlike conventional programs with arbitrary memory and execution time.

These differences mean prompt programming is best suited to tasks involving interpretation, reasoning, language, and pattern recognition rather than precise numerical computation or deterministic control.

Toward a genuine programming language

As LLM capabilities continue to improve, prompts are increasingly acquiring the characteristics of a high-level programming language. They support sequencing, branching, iteration, modularity, and abstraction, while delegating low-level implementation details to the model itself.

This suggests a shift in software development. Instead of writing imperative code that specifies every operation, developers increasingly write intent-oriented programs that describe goals, constraints, and decision logic. The LLM becomes the runtime that translates those high-level specifications into concrete reasoning and actions.

The natural next step is the emergence of dedicated prompt programming languages: languages with explicit syntax for variables, loops, conditions, reusable modules, external tool invocation, and error handling, but whose primitives are grounded in reasoning rather than arithmetic. Frameworks for AI agents already hint at this direction, combining natural-language instructions with structured control flow, memory, and tool calls.

In that sense, prompting is evolving from the art of writing good instructions into a new branch of software engineering. The programmer no longer writes every algorithm in detail; instead, they design the reasoning process itself. The program becomes a specification of cognition, and the LLM serves as its interpreter.