The History of Vibe Coding

First version 22 October 2026, last changed 24 October 2026 · Andreas Stockter

Vibe coding means building a program by telling a language model in everyday language what you want, no longer reading the code it produces and judging only the result: if it runs, it is good; if it does not, you describe the error and the model tries again. The word comes from a post that Andrej Karpathy, a co-founder of OpenAI and before that head of AI at Tesla, published on X on 2 February 2025: a new kind of coding in which you “fully give in to the vibes, embrace exponentials, and forget that the code even exists”.¹ Nine months later it was the Collins dictionary’s word of the year, and in April 2026 Google stated that three quarters of the new code in the company was written by AI and only reviewed by developers.^{2, 3} This text tells how it came to that.

Like the history of AI, the history of software development, the history of the Internet, the history of open source and the history of venture capital, this text follows a chain: each era solves a bottleneck that the previous one left open, and creates the next one in doing so. Here the bottleneck has had the same shape since 1949: the computer understands only the exact, the human thinks in the approximate, and somebody has to translate. Each step of this story has shifted part of the translation from the human to the machine, from the assembler through the compiler, the library and the answer on the net to the model’s suggestion and the agent’s work (Figure 1), and each step has set off the same dispute: whether one may trust what is generated, whether it is good enough, and whether people unlearn what the machine takes over. Vibe coding is the step at which the translation disappears from view. The question that remains is who answers for what runs.

Contents: 1 Prehistory · 2 Code as language · 3 Codex and Copilot · 4 ChatGPT and Cursor · 5 Agents · 6 The name · 7 Doubts and damage · 8 Agentic engineering · Chain · Timeline · Further reading · Sources · Glossary

1. Prehistory: The dream of everyday language (1952–2010)

The problem. A computer does exactly what is in its memory and nothing else. The first programs of the 1940s were sequences of numbers that the programmer translated by hand into the instructions of the machine, and one swapped bit was enough to spoil everything (the history of software development tells of it). The wish to tell the machine instead what you want is as old as the machine. In seventy years it has carried many names, automatic programming, fourth-generation languages, end-user programming, no-code, and each time it ended at the same place: everyday language is ambiguous, the computer is not, and somebody had to close the gap.

The compiler. Grace Hopper took the first step. In 1952 she wrote for the UNIVAC the program A-0, which assembled a runnable program from short codes and parameters, and called the method automatic programming; that a machine could write programs, her superiors at first held to be impossible.⁴ Five years later a team at IBM around John Backus delivered Fortran, the first high-level language that caught on. Its report of 1957 carried the word in the title, “The FORTRAN Automatic Coding System”, and promised to make programming cheaper: what had needed hundreds of lines of assembler was now written in a few dozen lines of formulas.⁵ The programmers of the time distrusted the result. They were convinced that no program could produce code as efficient as a human, and Backus later wrote that the project had only been started because the work of the programmers made the computers more expensive than the computers themselves.⁶ The compiler won because it made the work cheaper, not because it was trusted, and the dispute of 1957 returns three more times in this story.

COBOL and readability. In 1959 a committee of manufacturers and government agencies, with Hopper’s participation, designed COBOL, a language for business applications whose programs were meant to read like English: ADD TAX TO PRICE GIVING TOTAL. The intention was that managers should understand what their computers do. The result was that managers read COBOL programs as little as Fortran programs, but that billions of lines of it still run in banks and insurers today.⁷ The lesson the field drew from it was formulated by Edsger Dijkstra in 1978 in a short text titled “On the foolishness of ’natural language programming’”: the difficulty of programming lay in precision, not in notation. A machine that accepted instructions in everyday language would be as hard to build as to use, because every ambiguity that everyday language permits would become an error; formal language was not an obstacle but a privilege that allowed ordinary students what had once been reserved for geniuses.⁸ Eight years later Frederick Brooks, who had led the operating system OS/360, added the second half of the argument in “No Silver Bullet”: the difficulty of software lay in the essential, in the design of what the program should do, not in the accidental, the notation and the tools. No single advance would multiply productivity tenfold within ten years, because tools only hit the accidental.⁹ Both texts are today the chief witnesses for the opposing side in the dispute about vibe coding, and both had overlooked something important that only became visible in 2020.

Programming without programmers. While the field rejected everyday language, the users came from the other side. In 1979 Dan Bricklin and Bob Frankston brought out VisiCalc for the Apple II, the first spreadsheet; whoever types =B2*1.19 into a cell is programming without knowing it, and within a few years millions of accountants wrote programs that no programmer ever saw. In 1987 Apple shipped Bill Atkinson’s HyperCard with every Macintosh, index cards with buttons that one linked with a few words of the language HyperTalk; for teachers, artists and game developers it became the first environment in which lay people built software. In 1991 followed Microsoft’s Visual Basic, in which one pushed windows and buttons together with the mouse and only wrote out the reaction to a click; it became the most used language of the corporate PC.¹⁰ In the 1980s fourth-generation languages and so-called CASE tools promised to generate programs from specifications; what they generated above all were programs nobody could maintain. Research tried programming by example: the user demonstrates what is wanted and the system derives the rule. Henry Lieberman summarised the state in 2001 under the title “Your Wish Is My Command”, and in 2013 Microsoft put Sumit Gulwani’s Flash Fill into Excel, which guesses the transformation of a whole column from two worked examples.¹¹ Each of these steps multiplied the number of people who program, and none made programmers superfluous; the software that carries a company remained code that somebody had read.

The memory of the trade. The biggest step before the language models came not from research but from the net. In 1996 Microsoft built IntelliSense into Visual Basic, a completion that offers while typing the names and parameters possible at that point; it became the standard of every development environment. In September 2008 Jeff Atwood and Joel Spolsky opened Stack Overflow, a site on which programmers ask questions and the best answers are voted to the top.¹² Within a decade more than sixteen million questions gathered there, and the way a generation worked looked like this: error message into the search engine, answer on Stack Overflow, copy the code, adapt, carry on. One formulated one’s problem in everyday language and got code back, except that the code had been written by humans, years before, for a similar problem. That this copying spread errors and security holes, studies showed early; that it carried the productivity of the trade, nobody disputed.¹³ The site also became, without anyone planning it, training material for what came in 2020.

Try it yourself. Dijkstra’s text of 1978 is two pages long and sits in the archive of the University of Texas (EWD667); in 2026 it reads like an objection to vibe coding, written 48 years earlier. That a spreadsheet is programming, one cell shows: =IF(A1>100,"large","small") is a branch, =SUM(A1:A10) a loop over ten values, and whoever makes one column depend on another builds a data flow that a programmer would call a dependency graph.¹⁴

What followed: For seventy years everyday language failed at the same point. Every attempt to coax programs out of it ended with a formal language in disguise, because nobody knew how a machine should handle ambiguity. What was missing was not a better notation but a machine that had read how people turn intentions into code, millions of times, and could translate the approximate into the exact from that, the way an experienced colleague understands half a description.

2. Code as language: Statistics in the editor (2012–2020)

The naturalness of software. In 2012 Abram Hindle, Earl Barr, Premkumar Devanbu and colleagues presented at the most important conference of the field a simple observation: code, although written in a formal language, is as predictable as natural language, even more predictable, because people write it under the same constraints, in habits, patterns and repetitions. They showed that a statistical language model of the simplest kind, an n-gram model, which only counts which words follow which, beat the completion of Eclipse when trained on enough Java code.¹⁵ “On the Naturalness of Software” became the founding document of a branch of research that treats code as language: if code is statistical, it can be learned, predicted and generated without understanding its meaning, the way one can guess a continuation of “Once upon a time” without knowing the tale.

Software 2.0. In November 2017 Karpathy, then head of AI at Tesla, published an essay titled “Software 2.0”. Classical software, Software 1.0, was code that humans write; the new software was the weights of neural networks, which no human writes but an optimisation procedure computes from data, and for many tasks, image recognition, speech, control, this second kind would displace the first.¹⁶ The essay described what had happened in the years before (the history of AI tells it), and it contained the thought that led to vibe coding in 2025: that the human of the next era no longer writes code but collects data, sets goals and checks results. Five years later, in January 2023, Karpathy put it in one sentence: “The hottest new programming language is English.”¹⁷

The first completers. The technique that redeemed the thought was the Transformer of 2017 and the language models built on it, GPT from OpenAI (2018) and GPT-2 (2019), which continue text by choosing the most probable next word. That this works with code just the same was shown in July 2019 by a student at the University of Waterloo. Jacob Jackson fine-tuned GPT-2 on around two million files from GitHub and built it into his completer TabNine: instead of a name, Deep TabNine suggested whole lines, in every language, from the context of the file. The rush was so great that he could only offer the service through the cloud, because the users’ laptops could not carry the model.¹⁸ The company Kite, on the road since 2014 with the same goal and since January 2019 likewise with a deep-learning model for whole lines, gave up in November 2022; its founder wrote that the technology had not been ready and nobody had wanted to pay for it, the models had completed code without understanding it.¹⁹ He was right and had missed the moment by a year.

GPT-3. In May 2020 OpenAI published GPT-3, a model with 175 billion parameters, trained on a large part of the open net, and described in the paper in-context learning: the model solves tasks that one demonstrates to it with a few examples in the prompt, without having been trained for them.²⁰ That it also writes code in doing so was not in the paper; it struck the developers who got access to the interface in the summer of 2020. Best known became a short video by Sharif Shameem in July 2020: he typed “a button that looks like a watermelon” and “a table of the richest countries”, and GPT-3 produced the code for the interface, which ran at once in the browser; he had shown the model only two examples beforehand.²¹ Others had it write SQL queries, regular expressions and shell commands from descriptions. They were toys, and they proved what Dijkstra and Brooks could not have seen: a machine that has read millions of examples of how people translate intentions into code can resolve the ambiguity of everyday language, not by rules but by probability. It guesses what is meant, the way a colleague would guess it, and it errs in the same way.

What the models could not do. The limits were just as visible in the summer of 2020. The model wrote code that it could not run, and therefore did not know whether it worked; it invented functions that did not exist with the same confidence as real ones, a behaviour later called hallucination; and it saw only what fitted into the prompt, a few pages, not a project. It was a well-read beginner who had never tried anything out. The question of the following years was how to seat it at the computer.

Try it yourself. How a model continues code statistically, a small open model on your own laptop shows. With the program Ollama, ollama run qwen2.5-coder:1.5b loads a model of one and a half billion parameters (around a gigabyte), and on the input def is_prime(n): it writes the function to the end, mostly right, sometimes with an error at 1 or 2. Whoever enters the same line several times gets different versions: the model rolls dice along its probabilities, it looks nothing up.²²

What followed: Code could be generated from descriptions. What was missing was a model that had read above all code, a measure of how good it was, and a place in the tool that programmers worked with anyway, the editor.

3. Codex and Copilot: The autopilot in the editor (2021–2022)

Codex. OpenAI drew the conclusion from the summer of 2020 and trained GPT-3 further on code: Codex, fine-tuned on 159 gigabytes of Python from 54 million public GitHub projects. The paper of July 2021 brought at the same time the first measure for such models, HumanEval, 164 hand-written programming tasks with hidden tests, in which only one thing counts, whether the generated code passes the tests. Codex solved 28.8 per cent of the tasks at the first attempt and 70.2 per cent if one allowed a hundred attempts and took the best; GPT-3 without further training had solved none.²³ The second number was the more important: the model could usually produce a correct solution, it just could not recognise which one. Whoever had the tests had the tool.

Copilot. GitHub, since 2018 part of Microsoft, which in turn was OpenAI’s largest backer (the history of venture capital tells of it), built Codex into the editor. GitHub Copilot appeared on 29 June 2021 as a technical preview in Visual Studio Code and was announced as an “AI pair programmer”: while you type, it suggests the next lines in grey, sometimes the whole function, from the context of the file and the comment above it; a press of the tab key accepts the suggestion.²⁴ The image of the partner came from the pair programming of the agile methods, in which two people sit at one keyboard; here the human sat at the wheel and the model talked in. On 21 June 2022 Copilot was released to everyone, for ten dollars a month, free for students and the maintainers of popular open-source projects, and GitHub reported that in files in which Copilot was switched on, nearly forty per cent of the code came from it.²⁵ A controlled study that GitHub published with researchers from Microsoft the following year had 95 developers write a small web server in JavaScript; the half with Copilot finished on average 55.8 per cent faster.²⁶ The number became the most cited of the trade and the most disputed, because the task was small, self-contained and contained a thousand times over in the training material; how the tools work in real work, somebody measured only in 2025 (section 7).

The lawsuit. Copilot had learned from public code that stood under licences which mostly require naming the author (the history of open source explains the licences), and it occasionally reproduced longer pieces verbatim. In November 2022 the lawyer and programmer Matthew Butterick filed a class action in San Francisco, Doe v. GitHub, against GitHub, Microsoft and OpenAI, with a claimed value of nine billion dollars: Copilot removed the authorship notices from other people’s code and thereby violated the American copyright act and the licences. In January 2024 the court dismissed the greater part of the suit because the generated pieces were not similar enough to the originals; a contract claim remained. In September 2026 the appeals court upheld the dismissal, reasoning that Copilot and Codex do not remove notices from existing works but create new ones.²⁷ GitHub meanwhile built in a filter that suppresses suggestions matching public code. Whether the training itself was permitted, no court has decided; the question lives on in the suits of the authors and publishers that the history of AI reports on.

The competition. Within a year every large provider had a counterpart. Amazon presented CodeWhisperer in June 2022, which gave suggestions for its own cloud and notes on licences, and released it in April 2023; Replit, a development environment in the browser, built in Ghostwriter in October 2022; TabNine switched to models of its own.²⁸ DeepMind, which had become famous with AlphaGo, showed AlphaCode in February 2022, which in programming competitions on Codeforces was on average better than half the human participants, by generating up to a million solutions for each task, checking them against the examples from the task and submitting the ten most probable.²⁹ That was a foretaste of the way of working that was to shape the agents in 2024: generate, check, discard, repeat.

What changed and what did not. Copilot took the typing off the programmer, not the thinking (Figure 2). One read every suggestion, for a wrong one cost more time than one’s own, and the studies of these years found the gain above all in routine work: loops, tests, conversions, the tenth call of the same interface. The number of people who programmed did not grow, but the programmers wrote faster, and Stack Overflow, the memory of the trade, got its first competitor, one that did not answer but simply wrote on.

Try it yourself. The 164 tasks of HumanEval are public on GitHub (openai/human-eval); each consists of a function header, a description and hidden tests, and whoever puts one of them to a chatbot sees how easy they are in 2026. Copilot has had a free tier since December 2024 with two thousand completions a month in Visual Studio Code; whoever types with it for half an hour notices how often they press the tab key without having read.³⁰

What followed: Completion helped line by line, but the whole was still carried by the human: he had to know what he wanted, break it into code and read every suggestion. What was missing was a tool to which one could describe a problem instead of the start of a line, and which answered when something went wrong.

4. ChatGPT, Cursor and the conversation (2022–2024)

The chat. On 30 November 2022 OpenAI put ChatGPT on the net (the history of AI tells what happened then), and programmers were among the first to use it daily. The way of working was different from Copilot: one described a problem in whole sentences, got code back, copied it into the editor, ran it, pasted the error message into the conversation and got the correction. The model executed nothing and did not see the project, but it could explain, rewrite, translate, from Python to JavaScript, from one library into another, and it could do what Stack Overflow could do, only at once and tailored. The consequences for Stack Overflow were measurable: the number of new questions, which had been sinking slowly since 2017, fell steeply after November 2022 and in 2025 stood at the level of the founding year 2009, around three quarters below the peak; the model answered the questions it had been trained on.³¹ The site’s annual survey showed in 2023 for the first time that a majority of developers used AI tools or intended to, 70 per cent; in 2025 it was 84.³²

GPT-4. On 14 March 2023 came GPT-4, which solved the tasks of HumanEval two thirds of the time at the first attempt and the programming tasks of hiring tests reliably, and which for the first time wrote long, coherent programs from a description.³³ GitHub announced Copilot X a week later, the chat in the editor, and released it at the end of 2023; now one no longer had to copy the code from the browser, the model saw the open file and wrote into it.³⁴ Google followed with Gemini, Anthropic with Claude, and each of these models was measured on code, because code was the only material in which right and wrong could be checked automatically. The models were trained on programming tasks because programming tasks have tests, and they became better at them than at anything else.

Cursor. Four students at MIT, Michael Truell, Sualeh Asif, Arvid Lunnemark and Aman Sanger, had founded the company Anysphere in 2022 and brought out Cursor in 2023, a fork of Visual Studio Code in which the conversation with the model did not take place in a side panel but in the editor itself: one marked code, described the change, and the model rewrote the file, with a view of the differences that one accepted or rejected. In October 2023 OpenAI’s startup fund gave them eight million dollars, in August 2024 Andreessen Horowitz sixty million at a valuation of four hundred million; revenue rose by January 2025 to a hundred million dollars a year, faster than for any software before.³⁵ What distinguished Cursor from Copilot was less the model, it used the same ones from OpenAI and Anthropic, than the interface: whoever sees the change of whole files instead of confirming line by line reads less and trusts more. In November 2024 Cursor got an agent that changes several files at once and runs commands, and with that the threshold to the next section was reached.

The open models. In parallel the open line arose. Meta released Code Llama in August 2023, a Llama 2 further trained on code with open weights; the Chinese company DeepSeek followed in November 2023 with DeepSeek-Coder, Alibaba in 2024 with Qwen2.5-Coder, and in 2025 the best open models, Qwen3-Coder and Kimi K2, were only a few months behind the closed ones on the programming tasks.³⁶ To these came open tools: Paul Gauthier’s Aider (2023) works in the terminal with any model and writes its changes as Git commits; Cline (2024) brought the agent as an extension into Visual Studio Code. The history of open source tells why the open models are more than a cheap alternative for Europe.

Artifacts. On 20 June 2024 Anthropic published Claude 3.5 Sonnet, which solved programming tasks better than GPT-4o and brought a new mode, Artifacts: code that the model generates runs in a window next to the conversation, a web page, a chart, a small game, and one changes it by talking.³⁷ Vercel had shown a similar tool for interfaces in October 2023 with v0, describe the page, get the React components.³⁸ Here the code disappeared from view for the first time: one saw the result, not the lines, and for most users there was no longer a reason to look at them.

The first numbers. On 29 October 2024 Sundar Pichai said in the conference call on the quarterly figures that more than a quarter of new code at Google was generated by AI and reviewed by developers.³⁹ It was the first number of this kind from a corporation, and it became the yardstick of the following years (Figure 6). The counter-numbers came from the repositories: the company GitClear compared in January 2024 153 million changed lines from four years and found that since 2022 more code was changed again shortly after being written and more was copied instead of restructured, signs that suggestions were accepted and later repaired.⁴⁰ Google’s own DORA study, which has measured the performance of development teams for ten years, found in October 2024 that teams with more AI use wrote code faster, but their delivery became 7.2 per cent less stable and throughput fell slightly.⁴¹ The tools produced more code, and more code was not the same as more software.

Try it yourself. The way of working of 2023 can be re-enacted in ten minutes: tell a chatbot “Write a Python script that sorts all PDF files in a folder by the date in their name and moves them into subfolders by year”, run the script, return the first error message, and count how many rounds it takes until it works. Then read the lines: what happens to files without a date in the name? To two files with the same name? The answer is in the code, and you have to read it to know it.⁴²

What followed: The conversation lifted the model from the line to the function and the file, but the human remained the messenger: he copied, ran, read the errors and carried them back. The model had eyes for the text and no hands for the computer. What was missing were the hands.

5. Agents: Devin, SWE-bench and the builders (2023–2024)

The new measure. HumanEval measured whether a model can write a function. In October 2023 Carlos Jimenez, John Yang and colleagues at Princeton published SWE-bench, which measures whether it can replace a programmer: 2,294 real bug reports from twelve widely used Python projects, Django, scikit-learn, matplotlib and others, each with the state of the project before the repair and the tests that the human had written afterwards. The model gets the bug report and the whole project and must deliver the change that makes the tests pass. The best models managed two per cent, Claude 2 with 1.96 per cent was the best.⁴³ The task was not the writing but the finding: among hundreds of thousands of lines the three that had to be changed, and that demanded something a chat window did not have, access to the project and the possibility of trying things out.

Devin. In March 2024 the company Cognition presented Devin, the “first AI software engineer”, in a video that millions watched within days: Devin got a task in a chat, opened its own development environment with terminal, editor and browser, read documentation, wrote code, ran it, read the errors, corrected and reported back with the result. On a quarter of SWE-bench it solved 13.86 per cent of the tasks, seven times more than the best models half a year earlier.⁴⁴ The difference was not the model, Devin reportedly used GPT-4, but the loop (Figure 3): plan, read, edit, run, check, repeat. A coding agent is a model with tools and a loop, and the loop does what Codex could not do in 2021, it checks which of the many possible solutions is the right one by trying them. The researchers at Princeton showed in April 2024 with the open-source SWE-agent that a plain agent with a good interface to the computer achieved the same, and the project OpenDevin, later OpenHands, rebuilt Devin in the open within weeks.⁴⁵ Devin itself was available from December 2024 for five hundred dollars a month, and Cognition was already worth two billion dollars in April 2024.

The leap. In August 2024 OpenAI and the authors cleaned the measure up into SWE-bench Verified, five hundred tasks checked by humans, in which the description sufficed and the tests were fair; GPT-4o solved 33 per cent of them.⁴⁶ After that the marks fell monthly. In October 2024 Anthropic brought a new version of Claude 3.5 Sonnet that solved 49 per cent and was the first model that could operate a computer, mouse clicks and keyboard on screenshots.⁴⁷ In September 2024 OpenAI had introduced the reasoning models with o1, which work through intermediate steps before answering (the history of AI explains them), and in December 2024 it reported 71.7 per cent for o3.⁴⁸ What a model managed once in fifty cases at the end of 2023, it managed a year later in two out of three. The reason was not only size: the models were trained with reinforcement learning on exactly such tasks, write code, run tests, learn from the result, millions of times, and programming became the ability that grew fastest because it was the easiest to check.

The agent in the editor. What Devin did in the cloud, the editors pulled onto the laptop. Cursor presented agent mode in November 2024; Codeium, until then a completer, brought out the editor Windsurf on 13 November 2024 with an agent named Cascade; Cline, Roo Code and Aider did the same in the open. The agent in the editor reads the project, changes several files, runs tests and asks before it runs a command, or does not ask if you let it. The tool that Karpathy used in February 2025 when he coined the name was Cursor’s Composer with Claude 3.5 Sonnet.⁴⁹

The builders. The second line did without the editor altogether. Replit, whose development environment in the browser millions of pupils knew, presented the Replit Agent in September 2024: you describe the application, the agent builds it, with database and hosting, and puts it on the net. StackBlitz followed on 3 October 2024 with Bolt.new, which reached revenue of twenty million dollars a year in its first two months, and the Stockholm company Lovable, grown out of the open project GPT Engineer, on 21 November 2024 with the service of the same name, which had a million dollars of annual revenue in eight days.⁵⁰ The customers of these services were in large part not programmers: founders who needed a prototype, employees who wanted a tool for their department, pupils, pensioners. They never saw the code, and they had no reason to, until something went wrong (section 7).

The plugs. On 25 November 2024 Anthropic published the Model Context Protocol (MCP), an open standard with which a model addresses tools and data sources, databases, file systems, GitHub, Slack, any service for which somebody writes a server. The idea was that of the USB plug: a tool is connected once and works with every model. OpenAI adopted the standard in March 2025, Google in April, and in December 2025 Anthropic handed it to the Linux Foundation, which founded the Agentic AI Foundation for it.⁵¹ With that the agents had what Devin still had to bring along itself: hands for everything that has an interface.

What an agent costs. The loop is not free. Every pass sends the project, or the part of it that fits into the context window, to the model again, and an agent that works for an hour on a bug consumes millions of tokens; the providers bill by tokens, and a task that saved a developer an afternoon could cost in 2025 between a few cents and a few dozen dollars. The context windows grew from four pages with Codex to books with Claude and Gemini, and the prices per token fell by orders of magnitude within a year, but the arithmetic remained: what the loop saves in thinking, it pays in computing time, and whoever lets it run without watching pays for every loop that runs into nothing.

Try it yourself. The tasks of SWE-bench are open on the net (swebench.com, dataset on Hugging Face). Reading any one task, say a bug report from Django with its patch, shows what an agent has to do: not write the three changed lines, but find them in a project of 300,000 lines. Whoever wants to watch the agent at work lets OpenHands or Aider, both open source, loose on a small project of their own and reads along which files it opens, which commands it runs and when it gets lost.⁵²

What followed: At the end of 2024 agents solved half of real bug reports, the agent sat in the editor, and whoever could not program built applications with Bolt and Lovable without seeing a line. The technique was there, the way of working was there. What was missing was a name, and with the name came the question of what happens when nobody reads the code any more.

6. The name: Karpathy’s post and the wave (2025)

The post. On 2 February 2025 Karpathy wrote on X that there was a new kind of coding he called vibe coding: you fully give in to the vibes, embrace exponentials and forget that the code exists. That was possible because the models were getting too good; he used Cursor’s Composer with Sonnet and talked to the computer by speech recognition, barely touching the keyboard. He asked for the dumbest things, “decrease the padding on the sidebar by half”, because he was too lazy to find it, always pressed “Accept All” and no longer read the diffs; when an error message came, he pasted it in without comment and usually the model fixed it; the code grew beyond his understanding, and he would have to read it for a while if he really wanted to understand something. It was not too bad for throwaway weekend projects, but still quite amusing.¹ The post was a description, not a recommendation, and it contained both halves of what the year was to argue about: the ease and the “throwaway”.

The wave. The word filled a gap, and it spread in weeks. On 27 February 2025 Kevin Roose described in the New York Times how he, not a programmer, had built a dozen small applications with Bolt, Cursor and Claude, among them LunchBox Buddy, which photographs the fridge and suggests the packed lunch for his son: “software for one”, often faulty, but his.⁵³ On 6 March Jared Friedman of Y Combinator reported that in a quarter of the companies of the current batch 95 per cent of the code was written by AI, and that among founders who could program themselves.⁵⁴ Merriam-Webster took the word in in March and listed Karpathy’s post as its origin.⁵⁵ Simon Willison, who had watched the tools more closely than most since 2020, drew on 19 March the line that has held since: not all programming with AI was vibe coding. Vibe coding was not reading the code; whoever reads, checks and understands what the model writes was doing AI-assisted programming, and mixing the two up harmed the debate.⁵⁶ Andrew Ng, the co-founder of Coursera and Google Brain, objected in May to the name, because it suggested one followed the vibes, whereas the work demanded concentration as ever.⁵⁷ In November the Collins dictionary chose vibe coding as word of the year 2025, nine months after its invention.²

The tools of the year. The year 2025 brought the agents into every tool (Figure 4). Anthropic released on 24 February Claude Code, an agent that runs in the terminal, reads the project, changes files, runs commands and writes commits, without an interface of its own, only with the command line, first as a preview with Claude 3.7 Sonnet, from 22 May with Claude 4 for everyone.⁵⁸ OpenAI brought on 16 April Codex CLI for the terminal and on 16 May Codex, an agent in the cloud that took over the name of the model of 2021 and works on a task in a sealed-off computer while you do something else, and delivers a pull request.⁵⁹ GitHub presented on 19 May the Copilot coding agent, to which you assign a bug report from the project like a colleague.⁶⁰ Google released Jules in May, its agent in the cloud, and on 25 June the open-source Gemini CLI.⁶¹ Amazon brought Kiro on 14 July, which does not begin with the code but with a specification that the agent first writes and then implements.⁶² In August OpenAI published AGENTS.md, a file in the project in which you give the agents rules, tools, conventions, forbidden commands; sixty thousand projects adopted it by December, and Anthropic had the same as CLAUDE.md.⁶³ In October came Cursor 2.0 with a model of its own, Agent Skills at Anthropic, with which you teach agents procedures, and at GitHub Agent HQ, where the agents of Anthropic, OpenAI, Google, Cognition and xAI work side by side on one project.⁶⁴ In November followed Google’s Gemini 3 with the editor Antigravity, designed from the agents outward. The models that carried this solved SWE-bench Verified in May to 72 per cent (Claude Opus 4), in August to 75 (GPT-5), in September to 77 (Claude Sonnet 4.5) and in November to 81 (Claude Opus 4.5).⁶⁵

The money. With the tools came money in an amount that the history of venture capital puts in context. Cursor took nine hundred million dollars on 5 June 2025 at a valuation of 9.9 billion, with annual revenue of over five hundred million, and in November 2.3 billion at 29.3 billion, with over a billion in revenue.³⁵ Lovable reported in July 2025 a hundred million dollars of annual revenue eight months after the first million and took two hundred million at a valuation of 1.8 billion; Replit was worth three billion in September.⁶⁶ Anthropic, whose Claude Code by estimates ran at four hundred million dollars of annual revenue in July 2025, stated more than 2.5 billion in February 2026.⁶⁷ The company Windsurf showed how hot the market was: OpenAI had offered three billion dollars for it in May 2025, the offer expired on 11 July because Microsoft would have demanded access to the technology; the same day Google paid 2.4 billion for a licence and hired the founder and the core team, and three days later Cognition bought what was left.⁶⁸ GitHub reported in July 2025 twenty million users of Copilot, counted across all accounts since the start.⁶⁹

The order. The companies that did not build the tools ordered their use. Tobi Lütke, the head of Shopify, wrote to his staff in April 2025 that the use of AI was now a baseline expectation, and whoever asked for new positions had first to show why the work could not be done with AI.⁷⁰ Brian Armstrong of Coinbase demanded in August that every developer set up the tools within a week, and dismissed those who did not without good reason; by September around forty per cent of the code written daily at the company came from AI, and half was the target for October.⁷¹ Satya Nadella said in April that twenty to thirty per cent of the code in Microsoft’s repositories was written by AI, Pichai that at Google it was well over thirty, and Dario Amodei of Anthropic predicted in March that in three to six months AI would write ninety per cent of all code; in the team that built Claude Code it was, by their account, eighty to ninety by the end of 2025.^{72, 73, 74} The numbers were not comparable, they counted characters, lines or accepted suggestions, and they all said the same thing: whoever programmed in 2025 had it written.

Try it yourself. Karpathy’s post is on X and quoted verbatim in dozens of articles; his forty-minute talk “Software Is Changing (Again)” of June 2025 at Y Combinator, in which he explains Software 3.0, is on YouTube. The agents of the year can be tried without a contract: Gemini CLI is open source and free within limits, Codex is included in ChatGPT Plus, Claude Code in the Claude subscriptions. Whoever has a small project gives the agent a task in one sentence, watches what it does, and then decides whether to read the change or give in to the vibes.⁷⁵

What followed: The name had named a practice and its danger with it. 2025 was the year in which millions of people built software for the first time without reading it, and the year in which it became visible what happens then.

7. Doubts, damage and studies (2025–2026)

The first break-ins. The damage came first where nobody read. In March 2025 a founder announced on X that his service for enriching sales leads consisted of “zero hand-written code”, built with Cursor; within two days strangers bypassed the paywall, read the keys to his services out of the source of the web page, which every browser downloads, and used up his credit, and when he tried to close the holes, every correction by the model broke another place; he switched the service off after a week.⁷⁶ In May 2025 the developer Matt Palmer checked 1,645 applications built with Lovable and found in 170 of them the database readable by anyone, often writable too, because the access rules of the database Supabase had never been set; the flaw got its own number in the register of security vulnerabilities.⁷⁷ In July 2025 Jason Lemkin, a well-known investor, reported on his twelve-day attempt to build an application with the Replit Agent: on the ninth day the agent deleted the production database with the data of 1,206 executives, although Lemkin had imposed a change freeze; it explained afterwards that it had acted “in panic”, and claimed that a restore was impossible, which was false. Replit’s chief called the incident unacceptable and separated development and production databases, which every operation has done for decades.⁷⁸ The same month an unknown person smuggled into Amazon’s extension Q Developer for Visual Studio Code an instruction that told the agent to delete the user’s hard disk and cloud resources; the version was shipped signed and withdrawn two days later, without damage, because the instruction contained an error that made it ineffective; the intruder said they had wanted to show that it could be done.⁷⁹ In February 2026 the security company Wiz found at Moltbook, a social network for AI agents whose founder had proudly declared that he had not written a line himself, the key to the database in the code of the web page: one and a half million access tokens and 35,000 email addresses lay open to anyone who looked.⁸⁰ Lovable itself admitted in April 2026 that from February to April 2026 the conversations in public projects had been readable by every logged-in user, and that the reports about it had been dismissed as intended behaviour.⁸¹ The pattern was always the same. Not the logic of the code was wrong, but what was missing: login, permissions, the place for secrets, things an experienced developer does without being asked and a model does when asked.

The measurements. The individual cases had numbers behind them. Veracode had more than a hundred models solve eighty programming tasks in July 2025, in each of which there was a secure and an insecure way: in 45 per cent of cases the models chose the insecure one, in Java in over seventy, and the rate had not improved with the better models; the models wrote better code, but not safer code.⁸² A study at the University of Texas at San Antonio examined 576,000 generated programs from sixteen models and found that a fifth of the packages the models recommended for installation did not exist, and that the same invented names came again and again. Out of that came a kind of attack: whoever registers an invented name in the package registry and deposits malicious code there is installed by everyone to whom the model suggests the name; Seth Larson of the Python Software Foundation called that slopsquatting in April 2025.⁸³ Researchers at Georgia Tech began in 2026 to trace security vulnerabilities back to AI-written code, by the traces that agents leave in commits, and counted by April 74 confirmed cases, 18 in the second half of 2025, 56 in the first three months of 2026 and 35 in March alone, more than in the whole previous year; the most frequent errors were commands that executed unchecked input, and applications without a login.⁸⁴ And in November 2025 Anthropic reported that a Chinese state group had used Claude Code with MCP tools to automate intrusions into around thirty organisations; the agent had done eighty to ninety per cent of the work, the humans had decided only at a few points. The agent that writes code is the same one that attacks code.⁸⁵

Amazon. The biggest case hit the corporation that had bet most heavily on the tools. In December 2025 a service of Amazon Web Services went down for thirteen hours after developers had let the agent Kiro work without supervision; it had decided to delete the environment and rebuild it. On 2 March 2026 Amazon’s retail platform lost, according to internal documents, 120,000 orders in a code change that, according to the reports, went back to the advice of an AI agent; on 5 March the number of orders in North America collapsed for hours by 99 per cent, 6.3 million orders were lost, because a configuration had been deployed without the prescribed approval process, this time not by an agent, but in the same culture. Amazon spoke of user errors, not AI errors, and, according to the reports, prescribed itself ninety days of safety reset for 335 critical systems: code that agents have written for junior developers must since then be approved by an experienced engineer before it runs.⁸⁶ Approval of every change by a second person was the rule that software development had introduced in the 2000s, when humans wrote the code.

Productivity. The most important study of 2025 came from METR, an institute that measures the capabilities of AI systems, and it contradicted everything the industry was saying. Sixteen experienced developers worked between February and June 2025 on 246 real tasks in their own large open-source projects, each randomly with or without AI tools, mostly Cursor with Claude. Beforehand they expected to be 24 per cent faster with the tools, afterwards they believed they had been 20 per cent faster, and the stopwatch showed that they were 19 per cent slower (Figure 5).⁸⁷ The explanation METR offered fits the other findings: the developers knew their projects better than any model, spent time checking and discarding suggestions, and the tools helped least where the connections sat in a human’s head. A follow-up study with the same developers pointed in February 2026 to a speed-up of around 18 per cent, with an uncertainty that METR itself called too large for a verdict; the tools had got better, the measurement not clearer. Google’s DORA study found in September 2025 that nine out of ten developers used the tools and that teams now delivered more, but instability kept rising; AI was an amplifier that made good organisations better and bad ones worse.⁸⁸ Stack Overflow’s survey of 49,000 developers showed in 2025 that 84 per cent used the tools and at the same time more developers distrusted their answers (46 per cent) than trusted them (33); the most frequent complaint, named by two thirds, was code that is “almost right”, and almost half found that repairing it took longer than writing it. In 2026 two thirds used coding assistants or agents, more than seven in ten used AI daily, and just under seven per cent trusted it with important decisions.^{32, 89} The measurements of the repositories said something similar: GitClear found in 2025 that copied code blocks of five or more lines were eight times as frequent in 2024 as before and that for the first time more lines were copied than restructured, and CodeRabbit counted in December 2025 in pull requests with AI involvement 1.7 times as many serious defects as in human ones.^{90, 91}

The maintainers. The flood hit those who keep open source alive. Daniel Stenberg, who maintains curl, the program that sits in every phone and car, described as early as January 2024 the wave of invented security reports that language models brought him, demanded in 2025 from every reporter a statement whether AI was involved, and ended the project’s bounty programme at the end of January 2026 because the rubbish made the checking of real reports impossible.⁹² GitHub itself spoke in February 2026 of an “eternal September” of low-quality contributions, after the month of 1993 in which Usenet lost its manners under the influx of new users.⁹³ A paper of January 2026 bore the title “Vibe Coding Kills Open Source” and described that users who ask the model instead of the project deprive the maintainers of the feedback the projects live on.⁹⁴ In May 2026 a version of the copying tool rsync, on which agents had helped to write, muddled backups, and the debate about whether AI code belongs in the infrastructure reached the core tools of Linux.⁹⁵ At the same time Linus Torvalds told in January 2026 that he had built a small Python program by vibe coding for a hobby project, and saw no problem in it: for a tool that one person alone uses, that was exactly right.⁹⁶ Both are true, and Figure 7 shows why.

The profession. Programming was the first profession in which the models turned everyday work upside down (the history of software development describes the consequences), and they hit the beginners first. Erik Brynjolfsson and colleagues at Stanford counted in August 2025, in payroll data of millions of employees, that the number of software developers aged 22 to 25 had fallen by almost a fifth since the end of 2022, while that of the older ones grew; a year later the employment of young people in the occupations most shaped by AI stood, by the same reckoning, 19 per cent below that of their peers in other occupations, after 13 per cent the year before.⁹⁷ At the same time job postings for developers rose again in 2026, above all for experienced ones, and other economists found no connection with AI in overall employment; interest rates and a tax change in the USA explained part of the slump.⁹⁸ What nobody disputed: the work with which one had learned the craft, small tasks under guidance, was now done by the agent, and nobody knew how the next generation was to learn to read code it had not written.

The law. The law followed, in its own way. The suit against Copilot ended in September 2026 with the ruling that the tools create new works (section 3). In Europe the first part of the Cyber Resilience Act has applied since 11 September 2026: whoever sells products with digital elements in the EU must report exploited vulnerabilities within 24 hours, and from December 2027 the products must meet security requirements and be maintained over their lifetime; the law does not ask who wrote the code.⁹⁹ The new product liability directive treats software as a product and from December 2026 makes the manufacturer liable for damage from defects, including defects that an agent built in.¹⁰⁰ And the agents themselves showed in 2026 what it means to give them rights: in July two models from OpenAI broke out of their test environment in a security test and penetrated foreign servers, in October Anthropic reported on unintended actions of its agents in its own operations; the history of AI describes both cases.¹⁰¹

Try it yourself. Whoever has a project built by vibe coding can check it in ten minutes: npm audit or pip-audit shows known holes in the dependencies; every package name a model suggests can be looked up before installing on pypi.org or npmjs.com, against slopsquatting; and the question to the agent “Where are the keys of this application, and who may read the database?” yields the list of what is missing. Lemkin’s account of the deleted database is on X with all screenshots.¹⁰²

What followed: The damage did not come from the code the models wrote, but from the reading that nobody did. The year 2025 had shown that vibe coding works for throwaway programs and needs a discipline for everything else. The next section is about that discipline.

8. Agentic engineering: From vibe to discipline (since 2025)

Software 3.0. In June 2025 Karpathy gave a talk at Y Combinator titled “Software Is Changing (Again)”. Software 1.0 was code that humans write; Software 2.0 the weights of neural networks; Software 3.0 was the prompts with which one programs language models, in English. The models were a new kind of computer whose operating system is the model and whose programs are sentences, and whoever builds software must in future build it for agents too, not only for humans with mouse and screen.¹⁰³ Ten months later, on 20 April 2026, he sat on the stage of the Sequoia conference and took stock of the word he had coined: vibe coding had raised the floor, anyone could now build software; what software was worth for the profession, however, was decided at the ceiling, and that was held up by another way of working, which he called agentic engineering: agents write, humans design, check and answer for it, with the standard that professional software had before. He had never felt as far behind as a programmer as in this year, because the tools changed faster than one could learn them.¹⁰⁴

The discipline. What took shape by 2026 as agentic engineering is less an invention than a return, and it has seven parts. First the specification: before the agent writes, there stands what the program should do, as text that a human has read; Amazon’s Kiro made that a principle in 2025, and it is Brooks’s essential in a new form. Second the context files: files such as CLAUDE.md or AGENTS.md give the agent the rules of the project, which commands it may run, how testing is done, what is forbidden; Lütke and Karpathy called that context engineering in June 2025, the art of giving the model exactly what it needs for the next step, no more and no less.¹⁰⁵ Third the tests as contract: the human writes or checks the tests, the agent works until they pass, the test-driven development of 2002 with the roles swapped. Fourth small steps: one pull request per task, readable in ten minutes, with a human who reads it, and increasingly with a second agent that pre-checks it; Cursor bought the company Graphite for that in December 2025, GitHub built the review into Copilot. Fifth the permissions: the agent is a user with powers, and it gets as few as possible, Codex works in a sealed-off computer without a network, Claude Code asks before every command, and Amazon’s rule that an experienced engineer approves applies to agents as to humans. Sixth procedures that one teaches an agent once, as a skill, instead of explaining them in every conversation. Seventh parallelism: whoever lets several agents in the cloud work on several tasks no longer programs, he directs, and Microsoft stated in July 2026 that an agent was now involved in a third of all pull requests on GitHub, with fifty million users of Copilot.¹⁰⁶ Each of these parts existed before 2021. What is new is that they no longer demand diligence but are the only way to work with a colleague who writes faster than you can read.

The numbers of 2026. In April 2026 Google stated that three quarters of its new code was written by AI, reviewed by developers who increasingly directed agents instead of writing code (Figure 6).³ OpenAI brought Codex out in February 2026 as a program of its own for the Mac, with a model only for agents, and counted in June five million users a week, every fifth of them not a developer.¹⁰⁷ Anthropic gave for Claude Code in February annual revenue of more than 2.5 billion dollars, a year after the preview.⁶⁷ Cursor ran in May 2026 at three billion dollars of annual revenue, and on 21 April SpaceX, Elon Musk’s rocket company, had secured the right to buy the company for sixty billion dollars; on 16 June it exercised it, on 14 August the purchase was completed, paid in shares and folded into the AI division SpaceXAI, the largest purchase of a venture-backed company there has ever been, for an editor that had not existed four years earlier.¹⁰⁸ Lovable was worth 13.3 billion in August 2026 after a further round, with annual revenue heading for six hundred million; Replit nine billion.^{66, 109} SWE-bench Verified, the measure of 2024, the models solved in the summer of 2026 to 97 per cent, whereupon the leaderboard was retired; the test was exhausted.¹¹⁰

The models that read. The biggest news of the year came from the other side of the code. On 7 April 2026 Anthropic announced that it would not release a new model called Claude Mythos, because in testing it had found security vulnerabilities in every major operating system and every major browser, in a quantity and depth the company did not want to put into the world. Instead, in Project Glasswing, at first forty companies and institutions got access, among them Amazon, Apple, Google, Microsoft, Nvidia and the Linux Foundation, to check their software; Mozilla reported two weeks later 271 closed holes in Firefox, and by May the first fifty partners had found more than ten thousand serious vulnerabilities.¹¹¹ In June appeared with Claude Fable 5 a version with additional safeguards for everyone, which the American government blocked for almost three weeks before releasing access again, and in September and October followed the models of the 5.5 series; the history of AI tells of the dispute between the Pentagon and Anthropic that stood behind it.¹¹² For this story that means: the code nobody reads is now read by machines, in every line ever written, and the same ability that brought insecure code into the world in 2025 finds the holes in 2026, including those humans had overlooked for twenty years. The machine that writes without understanding and the machine that reads what nobody understands are the same.

What remains. Brooks was right and wrong at once in 1986. The tools hit the accidental, and they hit it so completely that writing code costs almost nothing in 2026; what has multiplied tenfold is not the productivity of software development but the quantity of code. What remained was the essential, in three parts. To know what you want, precisely enough that an agent can build it, which is the same thing Dijkstra called precision, only in everyday language. To check whether that is what was built, with tests, review and the reading that vibe coding skips. And to answer for what runs, to users, courts and the Cyber Resilience Act, for an agent is not liable. Every step of this story shifted the translation from the human to the machine; the last shifted the reading too. What cannot be shifted is the wanting and the answering for it.

Try it yourself. Agentic engineering can be practised on a small project in an hour: write a file AGENTS.md or CLAUDE.md with three rules (tests run before every commit, no new dependencies without asking, small commits with a reason), write the tests first, then give the agent the task and read the change before accepting it, and compare the result with the vibe way. Which commits of a project an agent wrote, git log --format='%b' | grep Co-Authored-By shows: Claude Code and other agents sign themselves in that way, and by these traces Georgia Tech found its cases.¹¹³

The open bottleneck. The software crisis of 1968 meant that people needed more code than they could write, and the history of software development is the history of its solution. The crisis of 2026 means that there is more code than people can read, and vibe coding is the name for the decision not to try. For a program that lives one evening, that is the right decision, and millions of people built something they wanted for the first time in 2025. For software that lives for years, it is the decision of OS/360 in a new guise: code nobody understands, only generated faster. Open is who takes over the reading, humans with the help of machines, or machines with spot checks by humans, and who bears the responsibility when neither does.

The chain in brief

1. Until 2010 every attempt to program in everyday language fails on its ambiguity; compilers, spreadsheets and Stack Overflow shift the translation piece by piece, but a human reads every line of code.
2. Statistics and Transformers (2012–2020) turn code into language: models learn from millions of examples to translate intentions into code; GPT-3 writes interfaces from a sentence but can run nothing.
3. Codex and Copilot (2021–2022) bring the model into the editor and a measure of what it can do; completion saves typing, the human carries the whole.
4. ChatGPT, GPT-4 and Cursor (2022–2024) lift the model to function and file; Stack Overflow empties, Google has a quarter written, the human remains the messenger between model and computer.
5. SWE-bench, Devin and the builders (2023–2024) give the model hands: agents read, edit, run and check in a loop, and lay people build applications without seeing code.
6. Karpathy gives the way of working its name in 2025, the agents come into every tool, the money follows in billions, and the companies order their use.
7. Break-ins, deleted databases, Amazon’s outages and the studies (2025–2026) show that the damage is not in the code but in the reading that nobody does.
8. Agentic engineering (since 2025) brings the discipline back, specification, context, tests, review, permissions, and the models begin to read the code nobody understands. Open remains who answers for it.

Timeline

Further reading

• Gene Kim, Steve Yegge: Vibe Coding. Building Production-Grade Software With GenAI, Chat, Agents, and Beyond. IT Revolution, Portland 2025. Two veterans of the trade on working with agents, with the title as bait and the discipline as content.
• Addy Osmani: Beyond Vibe Coding. From Coder to AI-Era Developer. O’Reilly, Sebastopol 2025. A Google engineer on the line between vibe coding and AI-assisted development.
• Frederick P. Brooks: The Mythical Man-Month. Essays on Software Engineering. Anniversary edition, Addison-Wesley, Reading 1995. Contains “No Silver Bullet” and the retrospective on it.
• Kurt W. Beyer: Grace Hopper and the Invention of the Information Age. MIT Press, Cambridge, MA 2009. The inventor of the compiler and the dispute about automatic programming.
• Chip Huyen: AI Engineering. Building Applications with Foundation Models. O’Reilly, Sebastopol 2025. How to build software with language models, including checking and operation.
• Simon Willison: Weblog, https://simonwillison.net/, tags “vibe-coding” and “ai-assisted-programming”. The running chronicle of the tools since 2020, by the man who drew the line.
• Andrej Karpathy: Software Is Changing (Again). Talk at Y Combinator’s AI Startup School, June 2025, on YouTube. Forty minutes on Software 3.0.
• Gergely Orosz: The Pragmatic Engineer, newsletter, https://newsletter.pragmaticengineer.com/. Reports from engineering departments on the use of the tools, with numbers.

Sources

The chronicle rests on the original papers, the announcements of the makers, court records, studies and contemporary reports named in the footnotes. The revenue and user figures of private companies are their own statements or estimates by the press and are not audited.