Three Paradigms

Seventy Stable Years, Then Two Shifts

Software stayed recognizably the same for about seventy years. You wrote instructions, a machine executed them.

Then it changed twice in a very short span.

Neural network weights became a second way to write programs. Natural language became a third. Andrej Karpathy names these Software 1.0, 2.0, and 3.0.

Software 1.0: Explicit Instructions

Software 1.0 is the classical stack you already work in daily.

You write explicit instructions in Python or C++. Every branch, loop, and condition is chosen by a human.

Karpathy frames it as identifying a specific point in program space that has the behavior you want. You navigate to that point by hand.

Notice that the vast field represents all possible programs, and the human hand marks just one point with the desired behavior.

Software 2.0: Weights, Not Code

Software 2.0 is written in the far more abstract language of neural network weights.

No human writes this code. You specify a goal, supply a dataset, and spend compute to search program space for a point that satisfies it.

The artifact you ship is a weight file rather than a readable function.

Software 3.0: English as Code

In Software 3.0 the programming language is English.

Large language models act as a new kind of runtime or operating system. Your prompt is the program that runs on them.

The job shifts from writing instructions to engineering the context window: specifying intent precisely enough that the model executes the task.

The Three Coexist

These paradigms are not replacements for one another.

Karpathy notes they coexist inside one system. Software 1.0 provides the infrastructure, 2.0 handles perception, and 3.0 manages high-level reasoning and natural language interaction.

So the design question is which layer a given problem belongs to.

Choosing the Right Paradigm

Use this when you scope work.

If the behavior is fully specifiable, write it as explicit code. If the behavior is easier to demonstrate with data than to state, train weights. If it needs high-level reasoning or natural language, prompt a model.

Most real systems will use all three at once.

From Code Author to Orchestrator

The practical consequence is a change in your role.

You move from being a code author to a system orchestrator who manages data and context.

The scarce skill is no longer only writing the function. It is deciding what belongs in code, what belongs in a dataset, and what belongs in a prompt.

A Python function in which a human writes every branch and loop is Software 1.0.

• True
• False

Answer: True

Software 1.0 consists of explicit instructions written directly by humans in languages such as Python or C++.

Software paradigms use different programming artifacts: Software 1.0 ships readable _____, Software 2.0 ships a _____, and Software 3.0 runs a natural-language _____.

Answer: Software paradigms use different programming artifacts: Software 1.0 ships readable code, Software 2.0 ships a weight file, and Software 3.0 runs a natural-language prompt.

Software 1.0 is expressed as readable code, Software 2.0 as learned neural network weights, and Software 3.0 as prompts for large models.

A team needs to detect objects in images. The desired behavior is easier to demonstrate with many labeled examples than to describe with fixed rules. Which paradigm is the best fit?

• Software 1.0, using hand-written branches
• Software 2.0, using trained weights
• Software 3.0, using a prompt only
• No software paradigm can solve the task

Answer: Software 2.0, using trained weights

Software 2.0 is appropriate when behavior is easier to demonstrate with data than to state explicitly. Training searches for neural network weights that satisfy the goal.