How we ended up programming without writing code

Every few months a new word shows up, and with it the same feeling: that there is a stack of knowledge out there, ordered and shared by people who arrived first, and that you joined late. First you had to learn to write prompts. Then it turned out context was the thing that mattered. Then tools, protocols, specs, evals, the harness. Now agentic engineering.

The feeling of being behind is real. The stack is not.

Underneath these seven years sits a much simpler pattern, and a considerably less flattering one. Every stage of this craft has been named after what the human stopped doing: typing the line, writing the sentence, reading the diff, watching the process, writing the code. And none of them settled until somebody, late and usually after a couple of incidents, wrote down the list of what you had to start doing instead. That second list never makes it into the announcement, because it sells nothing.

It has one more property worth stating early, because it explains everything else: every item on that second list is the hand-rebuilt version of a control that used to come included in the price. When writing code was expensive, that cost worked as quality control without anyone asking it to. Nobody generated forty files they had no intention of reading, because writing them hurt. Remove the cost and you remove the control. Everything we have learned since —context budgets, executable verification, permission boundaries, harnesses, evals— is the bill for that control, paid by hand and in arrears.

What follows is that history, ordered by surrenders rather than by years or products.

Autocomplete asked for nothing in return

The first stage is the one almost nobody tells, because it frightened no one.

Deep TabNine, in July 2019, was the first neural autocomplete in wide use: a GPT-2 fine-tuned on public code that guessed the end of your line. Its most visible rival was Kite, a separate and older company —founded in 2014, focused on Python— that had spent years selling the same promise from the cloud. Between the two of them they held the entire category. GitHub Copilot entered technical preview on June 29th, 2021 and general availability on June 21st, 2022, at $10 a month, and within months there was no category left to divide: on November 16th, 2022, Kite shut down and its founder published the post-mortem: half a million active developers, no revenue, and a conclusion —“individual developers do not pay for tools”— that Copilot had spent five months disproving at ten dollars a month.

What matters about those three years is what did not happen. Autocomplete demanded no new practice. It suggested, you accepted or rejected, and quality control stayed exactly what it had always been: you read the line. You gave up typing, not understanding. Review survived intact because the volume never moved: one suggestion fits in a glance.

It was the only free stage this craft has had, which is probably why it survives as the memory of a golden age that never was. It was cheap because it was small.

Chat moved the work inside the window

ChatGPT in November 2022 and GPT-4 a few months later changed the unit of work. No longer the line: the function, the file, the error pasted from the console. And with it came the first name in the series, prompt engineering, which promised that the craft was a matter of finding the right phrasing.

It lasted a short time as a discipline and deserved to, but it left two things behind. First, a role: in June 2023 swyx published “The Rise of the AI Engineer” and put a name to someone who was not a machine learning researcher and not quite an ordinary developer either. Second, a well-posed question: in October 2023 SWE-bench arrived, 2,294 real problems pulled from issues and merged pull requests across twelve Python repositories. The question was no longer whether the model wrote pretty code. It was whether it could resolve a real problem in a real repository.

What this stage surrendered was the first draft. What it asked in return, and almost nobody spelled it out at the time, was reading that draft in full before pasting it. It still worked, because copy-and-paste charged an attention toll: to move the code you had to look at it.

The loop was the leap, and the model did not make it

Between 2023 and 2025 the one genuine change of category in this story took place, and it happened outside the model.

ReAct, AutoGPT and BabyAGI fixed the shape —think, act, observe, repeat— while being, as products, fairly bad. Devin, in 2024, packed the three missing pieces into a sandboxed environment: a shell, an editor and a browser. The leap was not that the model wrote better code. It was that it could finally take an action, look at the result and try again. A model that is wrong and cannot check is a text generator. The same model with access to the tests is something else entirely.

In 2025 that loop came down to the terminal and turned into a consumer product. Claude Code, Codex CLI, Gemini CLI, OpenCode, and the veteran aider, which had been at it since 2023: different brands for the same idea, with the developer already out of the driver’s seat.

Here the surrender was the driving. What it asked in return —designing the environment the loop runs in, deciding what it may do without asking, and how you undo whatever it gets wrong— would take another year to acquire a name. That year of lag is where almost every incident later blamed on the models piled up.

Vibe coding was not a technique, it was a surrender announced out loud

In February 2025, Karpathy wrote the thing about giving in fully to the vibes, embracing exponentials and forgetting the code even exists. He later described it himself as a shower thought of a tweet, meant for weekend projects.

The term got loose, and it got loose in a very particular way: it came to name, without distinction, both Saturday’s throwaway prototype and the production system nobody reviewed. That Collins made it word of the year 2025 while Merriam-Webster picked slop sums that year up better than any analysis, and neither dictionary did it on purpose.

The term deserves some fairness, because the contempt that followed has obscured what was valuable in it. Vibe coding is the only stage on this list that was explicit about its surrender. It promised no new discipline and no better-paid role: it said out loud that you were going to stop reading the code, and left you to decide whether that was acceptable. As a bounded prototyping technique it remains legitimate and useful. The problem was never the practice; it was that it arrived without a single sentence about where the line was, and the industry took a year to write it.

Context stopped being text and became a budget

On June 19th, 2025, Tobi Lütke proposed context engineering in place of prompt engineering and defined it as the art of providing all the context needed for the task to be plausibly solvable. Karpathy amplified it six days later. In September, Anthropic formalized it.

That document is the first in the whole series that reads like engineering rather than manifesto, because it introduces the idea that organizes everything after it: the context window is not a warehouse, it is an attention budget. Every token you put in competes with the rest. Out of it come three techniques that are standard today and worth being able to name: compaction —summarizing the conversation as the window fills and restarting it with the summary, maximizing recall first and tuning precision afterwards—, structured note-taking —memory that lives outside the window— and subagent architectures, where each subagent burns tens of thousands of tokens in its own clean context and hands back one or two thousand of summary. And a fourth that changes the design of everything else: just-in-time retrieval, pulling content in only when it is needed, using lightweight identifiers —a file path, a query— instead of dumping it in just in case.

The surrender was writing the prompt. What it asks in return is knowing, at every step, what is inside the window, why it is there and what it costs to keep it there. It is the first time in this story that the second half of the deal is harder than the first.

We standardized the plugs before the discipline

Anthropic published the Model Context Protocol in November 2024. Zed published the Agent Client Protocol in August 2025, for the other axis of the problem: not how the agent talks to tools, but how it talks to the editor. In December 2025, three competitors put their pieces under one roof: Anthropic contributed MCP, OpenAI contributed AGENTS.md —the convention of always using the same filename for the file where a repository explains its rules to the agent— and Block contributed goose, its open-source coding agent, which runs on the developer’s own machine, works with any model and was one of the first to speak MCP. Those three donations founded the Agentic AI Foundation inside the Linux Foundation, with AWS, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft and OpenAI as platinum members. The press release carried two figures that say plenty: more than ten thousand published MCP servers, and AGENTS.md adopted by more than sixty thousand projects.

That is a remarkable standardization speed and it deserves the credit. That a protocol, a filename and an entire agent fit inside the same donation also says how unsettled the vocabulary was. But the thing worth looking at is the order.

We standardized the plug first —how an agent connects to a tool, to an editor, to another agent— and only then started arguing about the discipline: what is worth plugging in, who decides, what happens when the tool returns something hostile, who answers for it. It is the order that suits an ecosystem that needs to interoperate fast. It is exactly the reverse of the order that suits somebody who is learning, because connecting is trivial and deciding is where the craft lives.

The bill for that order arrived on time. In June 2025, Simon Willison had named the lethal trifecta: private data, untrusted content and an outbound channel. When the three of them meet in the same agent, poisoned text in any file it reads is enough to exfiltrate whatever is within reach, without a bug existing anywhere in anybody’s code. In 2026 it stopped being a warning and became a catalog of CVEs against specific coding agents, including at least one where the agent’s own output ended up redefining the boundary of its sandbox.

Specifications came back through the back door

The spec-driven movement is the most ironic part of this story, because it is a return dressed up as a novelty: when a machine writes the code, the place where human intent lives goes back to being the document that comes first. What we spent twenty years treating as bureaucracy turned into the valuable artifact.

The contribution that actually organizes the subject is not a tool, it is Birgitta Böckeler’s taxonomy, which separates three levels of ambition and heads off almost every sterile argument. Spec-first: you write a good specification, use it to drive the task, and the specification is allowed to die with the feature; it is the lowest-commitment level and it captures nearly all of the saved rework. Spec-anchored: the specification outlives the task and the feature evolves through it. Spec-as-source: the specification is the artifact you maintain and the code is its compiled output; it remains a research bet, however inevitable it gets sold as.

Almost everyone should stay at the first. Almost all the literature talks about the third.

In parallel the other half of verification matured, the evals, with two lessons worth more than any framework. The first is that you have to evaluate the trajectory and not only the result: which tool it picked, with what arguments, how many redundant steps it took, how it recovered from the error. The second lies in the difference between two metrics that sound alike and are not: pass@k measures whether it gets it right at least once in k attempts, and pass^k measures whether it gets it right every time. The second one describes production. The first one is the one that shows up in the announcements.

It took three years to give the environment a name

In February 2026 the industry found the word it had been missing since 2023 —harness— and adopted it with a haste that is better explained by the redistribution of blame than by the technical insight. Two pieces of the term matter for what comes next.

One: Mitchell Hashimoto’s ratchet principle. When the agent gets something wrong, you do not scold it in the chat; you change the environment so that particular error cannot happen again. It is the only known way for an environment to grow out of evidence rather than superstition.

Two: Böckeler’s distinction between computational controls —linters, types, tests, hooks: deterministic, cheap, instant— and inferential ones —another agent reviewing: expensive, slow and arguable—. The operating rule is to push the computational as far left as it will go and save the inferential for afterwards.

What this stage surrendered was supervision. What it asks in return is building the thing that supervises in your place, and that is engineering work with a budget of its own, not a configuration setting.

Agentic engineering is the name of the second half

In 2026, Karpathy retired his own term and proposed agentic engineering. His formulation is the best short definition of the current craft in existence: the professional discipline of coordinating fallible agents while preserving correctness, security, taste and maintainability. Agentic, because 99% of the time you are no longer writing the code directly, you are orchestrating whoever does and acting as oversight. Engineering, to insist that there is art, science and expertise in it.

And one line of his that puts everything above in order at a stroke: vibe coding raises the floor; agentic engineering is about extrapolating the ceiling.

What matters is the premise it starts from, which is the first honest premise in the whole series: the agent is fallible and stochastic. It does not return the same thing twice. It does not know when it has finished. Everything we have piled onto that second list —context budget, executable verification, permission boundaries, harness, evals, trajectories— exists solely because of that premise. It is, at last, a name that describes the second half of the deal instead of the surrender.

The craft is the second list

Seen whole, this history reads badly as progress and well as transfer.

Every stage took a task away from us and handed back a responsibility that was more abstract, harder to measure and worse paid in attention: we stopped typing and started judging; we stopped writing prompts and started managing budgets; we stopped reading the code and started designing how it gets checked; we stopped watching and started building the thing that watches. At every jump, what got announced was the surrender. What had to be learned was the second half of the deal, and it turned up a year late with a couple of incidents along the way.

The good news, if there is any, is that the second list is short and can be walked in order. Eight controls, not one of which carries the name of a product.

There is no reason to think the next word will work differently, or that it will take long to arrive. When it shows up, the useful question will not be what the human stops doing, because that part comes in the headline. It will be which control disappears along with it, and who is going to rebuild it.

That work —rebuilding by hand what slowness used to hand us for free— is the whole craft. It is not a temporary toll that the next generation of models will remove. It is what is left once everything else has been removed.