#The web ran out

In 2020 GPT-3 was trained on roughly 500B tokens scraped from the open web — Common Crawl, books, Wikipedia, code. That felt huge. Four years later it looks small.

#The Phi recipe: textbook-style synthesis

Microsoft's Phi line (Phi-1 → Phi-1.5 → Phi-2 → Phi-3 → Phi-4) is the single most influential public demonstration that small models can punch above their weight if you feed them better data instead of more data. The recipe is straightforward.

1. Curate a seed list of educational concepts — topics from textbooks, programming tutorials, mathematics curricula, reasoning patterns.
2. Prompt a strong teacher model (originally GPT-3.5, later GPT-4) to generate "textbook-style" expositions of each concept: definitions, examples, worked problems, common pitfalls.
3. Filter aggressively for quality. Phi-1 used an educational-content classifier; later iterations added perplexity gating, deduplication, and topic balance.
4. Train a small model from scratch on the resulting synthetic corpus.

The headline result of Phi-2 (released late 2023) was that a 2.7B-parameter model trained mostly on synthetic textbook-quality data outperformed Llama-2-7B — a model with ~2.6x more parameters — on a broad slate of common-sense and reasoning benchmarks. Phi-4 (December 2024) pushed this further: 14B parameters, ~100% synthetic training mix, performance competitive with much larger open-weights baselines.

#Self-Instruct and Alpaca: bootstrapping SFT from 175 seeds

The recipe is almost embarrassingly simple:

1. Hand-write ~175 seed instructions covering a diverse set of tasks — summarise this, explain that, write code for X, classify Y.
2. Repeatedly sample 8 of these as in-context examples and prompt a strong LLM ("write a new instruction in the style of the examples").
3. Have the same LLM write a response to its own newly-generated instruction.
4. Filter: drop near-duplicates, drop instructions that produce empty / refused / malformed answers, drop low-diversity outputs.
5. Fine-tune a target model on the resulting (instruction, response) pairs.

This is the moment "training your own ChatGPT clone" became something a graduate student could do over a weekend. It also forced every major lab to think carefully about whether teacher-output licensing terms applied to distilled students.

#Evol-Instruct: turn easy problems into hard problems

The trick is to treat instruction-difficulty as something you can climb, not something you can only sample. Evol-Instruct uses four prompt-engineered "evolution operators":

You apply one operator per iteration. A seed like "list three benefits of exercise" might evolve, after five rounds, into something like "for a sedentary office worker in their 40s with mild hypertension, compare three exercise regimes by VO2-max impact, joint-loading risk, and time cost, and justify which to start with assuming a 30-minute weekday window." Same shape, much harder.

The resulting WizardLM models (and the derivative WizardCoder for code, WizardMath for math) consistently outperformed Alpaca on benchmarks that test multi-step reasoning, which is exactly the dimension Evol-Instruct was designed to amplify.

#Persona-driven synthesis: the 1B-persona trick

The pipeline:

1. Build a large persona library. Persona Hub describes ~1 billion personas as Cartesian products of occupation × interests × demographic features × situational context. A persona might be "a 52-year-old veterinary surgeon in rural Wales who is learning Python to automate clinic billing."
2. Condition every synthetic prompt on a sampled persona: "Write an instruction this person would realistically send to an AI assistant."
3. Generate the response as normal — possibly with Evol-Instruct on top.
4. Filter and dedupe globally.

The diversity gain is dramatic. Without personas, "ask the model to generate an instruction" produces a heavy concentration of generic tasks. With personas, you cover the actual surface of human queries — including the long tail that benchmarks struggle to measure but real deployments live in.

#Distillation from strong teachers

A great deal of synthetic-data work is dressed-up distillation: have a strong model generate data, train a smaller model on it. This is how Alpaca was built; it is how a great deal of the open-weights chat ecosystem still works. The recipe is simple, but it has two failure modes you have to engineer around.

The standard mitigations: mix synthetic with a substantial real-data tail, regenerate from the base teacher periodically rather than chaining student-of-student-of-student, filter aggressively with a quality classifier, and use diverse personas / decoding temperatures to avoid mode collapse.

#Math: synthesise then verify

For mathematics, synthetic data is uniquely powerful because math has a cheap, exact verifier — you can check whether the final number is correct. MetaMath (2023) and the MathInstruct family pioneered the pattern.

The recipe:

1. Start with a real corpus (MATH, GSM8K, NumGLUE).
2. For each problem, ask the teacher LLM to generate multiple solution chains with explicit chain-of-thought.
3. Use the same teacher as a verifier — give it the problem and a candidate solution, ask "is this correct?"
4. Keep only the (problem, chain-of-thought, answer) triples where the verifier agrees and the final numeric answer matches a reference (when available).
5. Round-trip filter: paraphrase the question; run the solver again; demand the same final answer. Inconsistency under paraphrase is a strong signal of luck rather than reasoning.

#Self-Rewarding: closing the loop with no humans

The loop:

1. Start with seed instructions (Self-Instruct style).
2. Sample multiple response candidates per instruction.
3. Use the same model as an LLM-as-judge to rank the candidates against a rubric (helpfulness, correctness, conciseness).
4. Construct preference pairs (chosen, rejected) from the rankings.
5. Run DPO on these synthetic preferences.
6. The post-DPO model is both a better responder AND a better judge — iterate.

The Meta paper showed that this iterative loop produces consistent gains over multiple rounds, with the model improving as both responder and grader. The human input is minimal — only the seed instructions; the rest is the model judging itself.

#Model collapse: when the snake eats its tail

What happens, and Shumailov's group showed this in language, image, and Gaussian-mixture settings — is that the distribution narrows. Tails disappear first. Rare events, rare vocabulary, rare reasoning paths drop below the model's representational threshold and never come back. After enough generations the model is fluent but pathologically repetitive, having forgotten the part of the data manifold that was never well-represented in the synthetic outputs.

The empirical demonstrations in the paper are striking. For a Wikipedia-trained OPT-125M model resampled across nine generations, the model's outputs on the prompt "some books that some recommend to others" devolve from coherent recommendations into surreal repetition about jackrabbits within five generations. The math case is even cleaner — the Gaussian-mixture variance progressively shrinks until the support is a single mode.

#Constitutional / safety synthesis

Synthetic data is also how modern safety training works. The Constitutional AI line at Anthropic was the first widely-known instance.

The pipeline turns safety alignment into a self-supervised synthetic-data exercise:

1. Generate a response to a potentially harmful prompt — let the assistant answer freely.
2. Critique the response against a written constitution (a list of principles — be helpful, avoid harm, respect autonomy, etc.). The critic is the same model, in a different prompt role.
3. Generate a revised response that addresses the critique.
4. Use (revised, original) as a synthetic preference pair: chosen = revised, rejected = original.
5. Train via DPO / RLAIF on the resulting preference dataset.

This is synthetic-data generation pointed at alignment instead of capability. The human input shrinks to the constitution itself — a few hundred words. Anthropic's Claude line was the first commercial product to train its safety behaviour predominantly on data of this shape; the technique has since been widely adopted under various names (RLAIF, self-critique, principle-guided revision).

#A practical pipeline

If you are actually shipping a synthetic-data pipeline today, the canonical eight-step recipe looks like this:

1. Define the skill surface. What does the student need to be good at? Enumerate domains, task types, reasoning patterns, formats.
2. Curate seeds. Real examples per skill. Hundreds, not millions.
3. Generate at scale using a strong teacher LLM. Use personas for breadth and Evol-Instruct for depth.
4. Filter aggressively. Educational-content classifier, perplexity gate, format validator, near-duplicate removal (MinHash / SimHash), toxicity / PII screens, length caps.
5. Verify. Code → execution. Math → calculator + round-trip paraphrase. Prose → LLM-as-judge with a rubric. Without a verifier, you are gambling.
6. Mix with real data. Typical frontier mixes today are 50-90% synthetic, with the rest real for tail-of-distribution grounding. The Phi line is the high-end of synthetic share; most other labs sit lower.
7. Train and evaluate. Eval on held-out benchmarks AND on red-team probes targeting known synthetic-data failure modes.
8. Iterate on the gap. Identify skills where the student underperforms. Generate more data targeting those skills. Loop.

#Cost arithmetic: why synthetic wins

The economic argument is brutal. Suppose you need 1 trillion tokens of high-quality instruction-tuning data.

That is ~100x in favour of synthetic vs general human labour and ~500x against domain experts, at comparable token counts. The catch, repeatedly, is verification. The $600K cost gets you raw tokens; getting them to ship-quality requires the verifier infrastructure (execution sandboxes, math checkers, judge-LLMs, classifiers) on top. Even with the verifier overhead, the cost gap to human labelling is generally one to two orders of magnitude.

#Key takeaways