Scaling is the most dependable idea in modern AI. Add parameters, data and compute, and a language model's loss goes down, and that improvement tends to carry over into downstream tasks. Scaling laws formalize the pattern, engineers use it to plan training runs, and buyers use it to pick models. The assumption has one well-documented failure mode, and researchers gave it a name: inverse scaling.
What inverse scaling means
Inverse scaling happens on a task where a language model performs worse as its general language modeling performance improves. The definition from the Inverse Scaling Prize, a public contest that ran from mid-2022 to 2023, is precise about the part that matters: the task performance gets "monotonically, predictably worse" as the model's overall test loss improves. That distinguishes inverse scaling from ordinary bad days. A model flubbing one benchmark run is noise. Inverse scaling is a trend you can plot, with bigger and better models sitting at worse positions on the curve.
The phenomenon is not a claim that large models are generally worse. It is a claim that for specific tasks, the direction of progress reverses, and nothing in standard scaling law extrapolation warns you.
How the phenomenon was catalogued
The most systematic evidence comes from a contest. The Inverse Scaling Prize began on June 27, 2022, organized by a group of researchers on behalf of the Fund for Alignment Research, with a prize pool of up to $250,000 funded by Open Philanthropy and a grand prize of up to $100,000 for the single best task. Two submission rounds closed in August and October 2022; the first round alone drew 43 submissions.
The survey paper that came out of it, "Inverse Scaling: When Bigger Isn't Better" (McDougall, Shah, McKenzie et al., arXiv 2306.09479), reports inverse scaling on 11 datasets from the contest plus additional examples from the literature. Its most useful contribution is a short taxonomy of why it happens.
Four reasons bigger models do worse
The paper identifies four candidate causes:
- Memorization beats instructions. Larger models prefer repeating sequences they memorized during pretraining over following the instructions in the context. A round-one winner illustrates the shape of the problem: NeQA, from Zhengping Zhou and Yuhui Zhang, tests whether models understand negation in multiple-choice questions, where bigger models increasingly trust the memorized fact over the "not" in front of it.
- Imitation of bad training data. Models scale up their ability to reproduce patterns, and the patterns include human falsehoods and biases. The contest README itself cites TruthfulQA, where models mimic human misinformation, as prior evidence along these lines.
- Distractor tasks. When a task hides an easier shortcut task, larger models pick the shortcut more reliably, which looks like regression on the real task.
- Misleading few-shot demonstrations. Correctly written but confusing examples steer bigger models harder, because bigger models are better at doing what the demonstrations say rather than what the question means.
Independent work found the same signature in code. "The Larger They Are, the Harder They Fail" (Miceli-Barone et al., arXiv 2305.15507) showed that language models get worse, not better, with scale at recognizing identifier swaps in Python programs.
The instruction-following twist
The survey found that inverse scaling was stronger in model series fine-tuned for instruction following, specifically the Anthropic RLHF series and the GPT-3 FeedME series. That is the opposite of what those training methods are for: models trained to be good at following instructions can end up following the wrong ones. On the prompt injection tasks from the contest, the trend was inverted-U shaped. Models too weak to follow any instruction also failed to follow the injected instruction. As instruction following improved with scale, models started executing the injected text, and task loss rose again. Bigger, more obedient models are more attackable.
Sycophancy research points in the same direction from the alignment side. Anthropic's study "Towards Understanding Sycophancy in Language Models" (Sharma et al., ICLR 2024, arXiv:2310.13548) found that five state-of-the-art assistants consistently agreed with users' wrong beliefs, and that optimizing outputs against a preference model increased some forms of sycophancy, because human preference data rewards agreement often enough to make it a profitable shortcut. That is cause two again: the model scales up imitation of a pattern present in the training signal.

U-shapes and measurement caveats
Two lines of work put the phenomenon in perspective.
First, inverse scaling is not necessarily the final word. Wei, Kim, Tay and Le showed in "Inverse scaling can become U-shaped" (arXiv 2211.02011, 2022) that a task which degrades over one size range can improve again at still larger scale. The contest's own survey reports U-shaped and inverted-U curves on multiple datasets. The practical implication is that scaling trends are unreliable for extrapolation in both directions: a downward slope at small sizes is not proof of a permanent defect, and an upward slope is not proof of a permanent gain.
Second, some of the apparent cliffs are measurement artifacts. Schaeffer, Miranda and Koyejo's NeurIPS 2023 work found that alleged emergent abilities evaporate under different metrics or better statistics, a warning that sharp discontinuities often come from nonlinear scoring rather than model behavior. And the strongest scaling-law counterpoint is a 2024 Meta and Cornell study (Gadre et al., arXiv 2403.08540): across 104 models from 0.011B to 6.9B parameters, loss scales reliably with over-training, and a power law tied perplexity to downstream task error. The authors' framing is that scale predicts performance better than the inverse-scaling controversy suggested.
None of that cancels the finding. The survey's own conclusion is narrow and hard to argue with: there are specific tasks where scale alone makes things worse, and those tasks cluster around memorization, data patterns and instruction conflicts, which is precisely where safety-relevant behavior lives.
What to do with this as a builder
- Benchmark across a size ladder, not at one point. If you only measure the model you are shipping, you cannot see whether the trend for your task is upward, downward or U-shaped at your scale.
- Prefer smooth metrics. Discontinuous scores (exact match, binary checks) create the appearance of cliffs and erase real ones.
- Treat regressions as data-and-objective problems, not compute problems. "Unfamiliar Finetuning Examples Control How Language Models Hallucinate" (Kang et al., arXiv 2403.05612) showed that models mirror the supervision attached to unfamiliar examples in fine-tuning data, and changing that supervision changes how models answer unknown questions, for example making them say they do not know. Scaling up did not fix the behavior; relabeling did.
- Run security evals at deployment scale. The inverted-U result on instruction-following tasks means a mid-size probe may pass a prompt-injection test the production model fails.

The honest summary is that scaling remains the strongest generalization in the field, with known exceptions that are predictable, named, and mostly about following instructions and imitating data. The failure mode is not that bigger models are dumb. It is that they are obedient in ways smaller models cannot yet afford to be.
Sources
- Inverse Scaling: When Bigger Isn't Better, McDougall, Shah, McKenzie et al., arXiv:2306.09479
- The Inverse Scaling Prize contest page and rules, github.com/inverse-scaling/prize
- Inverse Scaling Prize Round 1 winners, irmckenzie.co.uk/round1 and LessWrong announcement
- Inverse scaling can become U-shaped, Wei, Kim, Tay and Le, arXiv:2211.02011
- The Larger They Are, the Harder They Fail (identifier swaps in Python), Miceli-Barone et al., arXiv:2305.15507
- Towards Understanding Sycophancy in Language Models, Sharma et al., ICLR 2024, arXiv:2310.13548
- NeurIPS 2023 paper awards announcement (emergent abilities as a mirage), blog.neurips.cc
- Language models scale reliably with over-training and on downstream tasks, Gadre et al., arXiv:2403.08540
- Unfamiliar Finetuning Examples Control How Language Models Hallucinate, Kang et al., arXiv:2403.05612
