A resource nobody found lying around
It is easy to talk about training data as though it were a natural resource — something a project either has enough of or runs out of, like water or ore. The history does not support that picture. At almost every point where machine learning needed more signal than the world had directly handed it, the field’s response was not to go looking harder. It was to manufacture.
That manufacturing took different forms in different decades, and the forms matter, because “synthetic data” is not one invention with one origin story. It is a sequence of specific, dated engineering decisions: a photograph transformed into several; a large model’s output used to shape a small one; a game system trained on nothing but games it played against itself; the open web treated as raw ore to be filtered rather than an archive to be read; a mathematical proof generated and then checked by a system that cannot be fooled by fluency; and, most recently, the deliberate, industrial-scale generation of the very examples used to align a model’s behaviour. Each of these predates the current argument over whether a model can safely train on its own output, and each one shaped what that argument is actually about. This is the history in order, with the people, the papers and the dates attached.
Manufacturing more from one photograph
The clearest starting point is 2012, and the clearest reason is that it is exceptionally well documented. Alex Krizhevsky, Ilya Sutskever and Geoffrey Hinton’s convolutional network — later known simply as AlexNet — won that year’s ImageNet competition by a wide margin, and the paper describing it is explicit about a technique that had existed in scattered form before but had never been shown to matter at this scale: data augmentation [1].
The method was almost aggressively simple. From each 256-by-256 training image, the network was shown randomly selected 224-by-224 patches together with their horizontal mirror images, which multiplied the effective size of the training set by roughly two thousand and forty-eight times. A second, subtler technique altered the intensity of each image’s red, green and blue channels using principal component analysis, adding multiples of the image’s own principal colour components so that the network saw the same object under many plausible lighting conditions rather than one fixed rendering. The paper reports that this second step alone reduced top-1 error by more than one percentage point — a nontrivial fraction of the gap between AlexNet’s final 37.5 percent top-1 and 17.0 percent top-5 test error and the previous state of the art [1].
What is worth sitting with is what this technique was and was not. It manufactured no new information about the world. A cropped, flipped or recoloured cat photograph is still, in every sense that matters to a human, a picture of the same cat. What augmentation bought was invariance: it forced the network to represent “cat” as something that survives translation, reflection and lighting change, rather than memorising the specific pixels of specific training photographs. This is the oldest and most conservative form of manufactured training data, and it is instructive precisely because it is so cautious — it never asks a model to learn from an example that was not, at some level, a real photograph of a real thing.
The next step loosened that constraint. In 2014, Ian Goodfellow and collaborators described a framework in which two networks are trained against each other: a generator that tries to produce samples indistinguishable from real data, and a discriminator that tries to tell them apart [2]. Where augmentation perturbed a real photograph, a generative adversarial network could synthesise an image with no single real photograph behind it at all. The conceptual distance between crop-and-flip and a generative adversarial network is the distance this whole history keeps re-crossing: from transforming what you have to manufacturing what you do not.
A teacher’s dark knowledge
If augmentation is the oldest form of manufactured data, distillation is the oldest clean instance of one trained model’s output becoming another model’s training signal — not a transformed photograph, but a fresh target computed by a network and handed to a different network to learn from.
The technique had informal predecessors, but it was Geoffrey Hinton, Oriol Vinyals and Jeff Dean’s 2015 paper that gave it its lasting name and its cleanest formulation. Their argument starts from an observation about what a trained classifier’s raw output actually contains. A one-hot label says only “this is a two.” A trained network’s full softmax output, before it is rounded to a hard decision, says something considerably richer: it assigns the wrong answers small but structured probabilities, so that “two” gets a little more mass on “seven” than on “cat,” reflecting genuine visual similarity the hard label discards entirely. Hinton, Vinyals and Dean called this extra structure “dark knowledge,” and showed that a small “student” network trained to match a large “teacher” network’s softened output distribution — rather than the ground-truth hard labels — could recover much of the teacher’s accuracy at a fraction of its size, demonstrating the technique on MNIST digit classification and on an acoustic model already in commercial use [3].
Distillation deserves a specific place in this history because of what it structurally is not. The teacher does not change during the process; nothing the student produces ever flows back into it. The chain runs exactly one step, from a fixed, already-trained source to a single downstream copy, and the goal is transfer of a known distribution rather than improvement beyond it. Every later argument in this history about whether training on generated data is dangerous will eventually need to explain why distillation, which is entirely generated data by definition, was never considered a case of concern. The answer that recurs across four decades of practice is structural: a closed loop with no outside input is a different object from a single, deliberate hop from a fixed source.
Learning by playing yourself
Distillation moved one model’s knowledge into another. A separate and much older lineage in the history of manufactured training data solved a harder problem: what to do when there is no teacher and no existing dataset at all, because the task is one no one has ever played well before.
Writing in Communications of the ACM in 1995, Gerald Tesauro described TD-Gammon, a backgammon-playing program built on temporal-difference learning. Its training data was not backgammon games played by human experts. It was games the network played against itself, move after move, starting from a randomly initialised evaluation function that at first played close to randomly. Tesauro records that despite this unpromising start, the network gradually acquired increasingly sophisticated positional concepts purely through self-play, to the point that world-class human players later adopted some of its strategic judgements — most notably around certain doubling-cube and racing decisions — as improvements on established human theory [4]. TD-Gammon is the earliest well-documented case in this history of a system whose entire training curriculum, from the very first example onward, was generated by the system itself.
For two decades that remained closer to a curiosity than a template. It returned to the centre of the field in 2016, when David Silver and colleagues at DeepMind published AlphaGo. Its value and policy networks were trained by a combination of supervised learning on a large corpus of human expert games and reinforcement learning from games played against itself; the resulting system defeated the reigning European Go champion five games to none in a formal match and won 99.8 percent of games played against other Go programs [5]. Human game records were still doing real work in that recipe — self-play supplemented a human-authored dataset rather than replacing it.
The step that mattered most for this history came a year later, when Silver and colleagues described AlphaZero. It removed human game data from the training process entirely. Given only the rules of chess, shogi and Go, and starting from random play, AlphaZero trained purely by playing against itself, with no opening books, no endgame tables and no example games of any kind beyond the ones it generated on its own. Within twenty-four hours of training it reached a superhuman level of play in all three games and convincingly defeated a world-champion program in each one [6]. Nearly a quarter-century after TD-Gammon, self-generated data had gone from a curiosity that worked for one game to a general method that needed no human demonstrations at all — a milestone that arrived years before “synthetic data” became a phrase applied routinely to language models.
The web becomes a corpus
While self-play was answering the question of what to do when no dataset exists, a parallel and much larger transformation was underway in how language systems got their data at all, and it began with an infrastructure project rather than a modelling paper.
Common Crawl was founded in 2007 by Gil Elbaz, who had previously co-founded Applied Semantics before its acquisition by Google, with the explicit goal of giving researchers who lacked their own web-crawling infrastructure access to web-scale data. The organisation began collecting crawl data in 2008 using custom crawling technology, later replacing it in 2013 with a system built on Apache Nutch; by the mid-2020s its open, freely available archive — distributed through Amazon Web Services — exceeded ten petabytes of crawled web pages spanning most of two decades [7]. For roughly a decade after its founding, Common Crawl functioned mainly as public infrastructure that specific research groups drew on selectively rather than as the default substrate for training a language model.
The large language models that first demonstrated the power of generative pretraining did not, in fact, start from Common Crawl directly. Alec Radford and colleagues at OpenAI trained their 2018 Generative Pre-Training model — what would later be called GPT-1 — on BooksCorpus, a collection of roughly seven thousand unpublished books chosen specifically because they offered long, contiguous passages of text useful for learning long-range dependencies; the resulting model improved on the state of the art in nine of the twelve language-understanding tasks the authors studied [8]. Later that year, Jacob Devlin and colleagues at Google released BERT, trained on that same BooksCorpus together with English Wikipedia — a deliberately curated combination of edited prose, not a raw web scrape [9].
The move that made Common Crawl itself the default pretraining substrate came in 2019, when Colin Raffel and colleagues, building the T5 model, took a large snapshot of Common Crawl’s raw web archive and applied an extensive cleaning pipeline — removing boilerplate, deduplicating near-identical pages, filtering by heuristics for coherent English prose — to produce what they named the Colossal Clean Crawled Corpus, or C4 [10]. That step is the real hinge in this part of the history. Before it, “training data” for a language model meant a dataset someone had assembled with intent — a set of books, an encyclopedia. After it, training data increasingly meant the open web itself, filtered rather than authored, with the filter doing the work a curator used to do by hand.
Where a checker exists
Self-play worked because a game supplies its own ground truth: a win is a win. Most domains offer no such guarantee, which is what makes one 2024 result worth treating as its own distinct chapter rather than a footnote to either self-play or web-scale scraping.
Trieu Trinh and colleagues, publishing in Nature, confronted a domain — Euclidean plane geometry theorem-proving — where the scarcity of machine-verifiable training examples was severe, because translating a human geometry proof into a format a machine can check is itself a difficult, largely unsolved translation problem. Their system, AlphaGeometry, sidestepped human demonstrations entirely: it synthesised around one hundred million unique theorems and proofs spanning a wide range of complexity, using no human-authored proof as a template, and trained a language model from scratch on that entirely synthetic corpus to guide a symbolic deduction engine through the branching search space of a geometry problem. On a held-out test set of thirty recent olympiad-level problems, the system solved twenty-five, compared with ten for the previous best automated method, placing its performance close to that of an average International Mathematical Olympiad gold medallist [11].
What makes AlphaGeometry belong in this history as a distinct category, rather than as another instance of self-play or another instance of scale, is what stood between the generated data and the model that learned from it: a symbolic deduction engine, which does not share a language model’s failure modes and cannot be talked into accepting an invalid proof by fluent-sounding reasoning. Every one of AlphaGeometry’s hundred million training examples was generated with no human oversight, and every one of them was also formally checked before it ever reached the training set. The two facts are equally important, and the second is the one that later “model collapse” debates would return to as the property that changes everything.
The 2020s: post-training becomes a data-generation industry
By the early 2020s, a further and much larger shift was underway. Where AlphaGeometry manufactured data for a domain with a formal checker, a wave of work manufactured data for the much less formal problem of getting a language model to behave the way its operators wanted — and did so, for the first time, as the default and expected method rather than a special case.
Yizhong Wang and colleagues’ Self-Instruct, presented in 2023, showed how far this could be pushed with almost no human writing at all. Starting from a small seed set of human-written instructions, the method prompted a language model to generate large numbers of new instructions and example responses, then filtered out low-quality or near-duplicate generations before using what remained to fine-tune the same class of model. Applied to GPT-3, the resulting model showed roughly a thirty-three percentage point absolute improvement over the unmodified base model on the Super-NaturalInstructions benchmark, a gain the authors reported as comparable to a model trained with substantial private human annotation [12]. The training examples were themselves entirely model-generated; what made the method work was the filtering step standing between generation and training.
Reinforcement learning from human feedback arrived the same year in a form that would become the template for the rest of the decade. Long Ouyang and colleagues at OpenAI described InstructGPT: supervised fine-tuning on a modest set of human demonstrations, a reward model fitted to comparisons between pairs of model outputs ranked by human labellers, and reinforcement learning of the policy against that reward model. The headline finding is worth restating because it is so often flattened in summary — a 1.3-billion-parameter InstructGPT model was preferred by human raters to the 175-billion-parameter GPT-3 it was derived from, despite having more than a hundred times fewer parameters [13]. Reinforcement learning from human feedback did not, by itself, generate training text the way Self-Instruct did; what it generated, at scale, was preference judgements, which then shaped what the model learned to produce.
Anthropic’s Constitutional AI, described by Yuntao Bai and colleagues later that same year, pushed the same idea one step further by replacing much of the human preference-labelling itself with labels generated by another model. In the supervised phase, a model critiques and revises its own responses against a written set of principles; in the reinforcement phase, a separate model judges which of two candidate responses better follows those principles, and that judgement — not a human comparison — supplies the reward signal, a method the authors term reinforcement learning from AI feedback [14]. By the close of 2022, in other words, the dominant method for shaping a deployed language model’s behaviour was itself substantially model-generated: synthetic instructions, synthetic preference judgements, or both, at a scale no purely human-annotated pipeline could match. What had been, in the AlexNet era, a way of stretching a fixed set of photographs had become, a decade later, the primary mechanism by which a model’s behaviour was built at all.
The recursion problem: the field learns to watch its own tail
Every chapter to this point involves a model learning from data that some other process generated — a transformed photograph, a teacher network’s soft output, a game played against a fixed copy of itself, a filtered scrape of the open web, a formally checked proof, a critiqued and revised response. What none of them involve, by construction, is a model training on a large, unfiltered, unchecked sample of its own kind’s own output, repeatedly, across generations, with no outside correction. That specific configuration did not get a name and a systematic treatment until 2023.
In May of that year, Ilia Shumailov and colleagues posted a preprint titled “The Curse of Recursion: Training on Generated Data Makes Models Forget,” introducing the term “model collapse” for the degenerative process that results when generative models are trained recursively on content produced by themselves or by other generative models, describing the resulting defects — the disappearance of the low-probability tails of the original data distribution — as irreversible under that recursive setup [15]. The following year the same core group published a peer-reviewed version in Nature under the title “AI models collapse when trained on recursively generated data,” which formalised the mechanism into two phases: an early phase in which rare events and distributional tails are lost first, and a later phase in which the distribution collapses toward a much lower-variance approximation of its former self. The authors demonstrated the effect across variational autoencoders, Gaussian mixture models, and a 125-million-parameter language model, and reported that periodically injecting a share of fresh, real data back into the training mix substantially limited the degradation [16].
What is most striking about this part of the history is how fast the field’s understanding moved after that. Within roughly the same year, Matthias Gerstgrasser and colleagues published a result that sharpened rather than contradicted the original finding: they showed that replacing real training data with each generation’s synthetic output does indeed drive a system toward collapse, largely reproducing the original result, but that accumulating successive generations of synthetic data alongside the original real corpus — rather than discarding the real data as synthetic data arrives — avoids collapse, with a provable bound on test error that holds regardless of how many generations accumulate. They validated this across transformer language models, diffusion models, and variational autoencoders [17]. Barely a year separated the paper that named the danger from the paper that identified precisely which structural assumption — full replacement of real data, with nothing preserved from outside the loop — was doing the damage. That assumption, as the earlier chapters of this history make clear, was never how AlexNet’s augmentation, Hinton’s distillation, AlphaZero’s self-play, C4’s filtered scraping, or AlphaGeometry’s checked proofs actually worked; each of those methods kept a channel open to something outside the generative loop, whether a real photograph, a fixed teacher, the rules of a game, a cleaning heuristic, or a symbolic verifier. The 2023-2024 model-collapse literature did not discover that synthetic data was dangerous. It discovered, and dated precisely, the one specific configuration under which forty years of otherwise-successful practice would not have worked.
What the arc adds up to
Read in sequence rather than as isolated results, this history has a single throughline. At every stage, the field found a way to manufacture more usable training signal than the world had directly supplied, and at every stage the manufacturing method kept some form of connection to something outside itself: a real photograph being transformed rather than invented from nothing; a fixed, already-trained teacher rather than a moving target; the fixed rules of a board game rather than a model’s own untested claims; a filtering heuristic standing between the raw web and the training corpus; a symbolic engine that could not be talked into a false proof; a written constitution and a human-authored seed set anchoring an AI-generated preference signal. The 2023-2024 model-collapse literature is not a rupture in that story. It is the moment the field, having spent four decades building an ever more sophisticated practice of manufacturing its own training material, finally asked in a systematic, dated, publishable way what happens on the rare occasions when that outside connection is severed altogether.
That question remains active research, and later work in this series takes up what current evidence says about when collapse actually occurs, what a practitioner should do about it, and where the unresolved arguments sit. This piece has had a narrower aim: to show that none of that debate starts from a blank page. It starts from AlexNet’s cropped photographs, Hinton’s soft targets, Tesauro’s self-taught backgammon player, Common Crawl’s decade-old archive, AlphaGeometry’s checked proofs, and a 2022 alignment pipeline already built almost entirely from data a model generated about itself — a full history of manufactured training data, each step dated, attributed, and still running underneath the frontier systems built on top of it.
