Two results in deep learning falsify the first thing most of us were taught about generalization, and they are not edge cases or lab curiosities. Grokking shows a network can memorize its training set completely, sit there overfitting for tens of thousands of steps, and then abruptly start generalizing. Double descent shows that making a model bigger — well past the point where it can fit the training data exactly — can make it generalize better, not worse. Both are reproducible. Both contradict the bias-variance story that a generation of practitioners internalized as physics. Taking them seriously forces an uncomfortable admission: we do not have a settled theory of why deep networks generalize, and the intuitions we reach for are unreliable exactly where the interesting behavior lives.
Let me argue that carefully, because the details are where the surprise is.
The intuition being broken
The classical picture is the U-curve. As you increase model complexity, bias falls — the model can express richer functions — but variance rises, because a flexible model chases noise in the particular training sample it saw. Test error is the sum, so it traces a U: too simple underfits, too complex overfits, and there is a sweet spot in the middle. The operational rules that fall out of this are the ones everyone repeats. Do not fit your training data exactly. A model with more parameters than data points will overfit. If it has memorized the training set, it will not generalize.
This is not folklore; it is a real consequence of a real theory. Classical statistical learning theory bounds generalization error in terms of a capacity measure — VC dimension, Rademacher complexity — and those bounds get worse as capacity grows relative to sample size. The math is sound. The problem is that it stopped describing the models we actually train.
The first crack was empirical and blunt. Zhang and colleagues showed in 2017 that standard image networks can fit training sets with the labels randomly shuffled — they reach zero training error on pure noise. Any capacity measure large enough to permit that is large enough to permit memorizing anything, which means the bound says nothing about the case where labels are real and the same network generalizes fine. The classical apparatus was not wrong; it was vacuous. Grokking and double descent are what the territory looks like once you stop trusting that map.
Grokking: generalization that arrives late
Power and colleagues at OpenAI reported grokking in 2022 on small algorithmic tasks — the cleanest is modular arithmetic. Train a small transformer to compute (a + b) mod p for a prime like 97 or 113, giving it some fraction of the possible pairs as training data and holding out the rest. Watch two curves: training accuracy and test accuracy.
Training accuracy does the expected thing. It climbs and saturates at 100% fairly quickly — the model has enough capacity to memorize every training pair as an arbitrary lookup table. At that moment the classical verdict is in: it has interpolated the training set, test accuracy is near chance, this is textbook overfitting, you should have stopped already.
Then you keep training. For a long time — often orders of magnitude more steps than it took to memorize — nothing visible happens. Training accuracy stays pinned at 100%, test accuracy stays near the floor. And then, well past the point any early-stopping rule would have fired, test accuracy climbs, sometimes almost vertically, to near 100%. The model that had "merely memorized" now generalizes to pairs it never saw.
The word "grok" is apt because something did click, and we can say what. Nanda and colleagues reverse-engineered the grokked network for modular addition, and it is not running a subtler lookup table — it has discovered an algorithm. It embeds each integer $k$ as a set of angles $2\pi k n / p$ around the unit circle, so that modular addition becomes rotation: adding $a$ and $b$ composes their angles, and the network reads the result off through what amounts to trigonometric identities across a handful of discrete frequencies. That structure did not exist during the memorization phase. It formed gradually, underneath a flat accuracy curve, and generalization appeared at the moment the algorithmic circuit outcompeted the memorized one.
Two things about the mechanism matter for the larger point. First, grokking depends heavily on regularization — weight decay in particular. Without it, the sudden generalization is weak or absent; the pressure to shrink weights is what makes the compact algorithmic solution win over the sprawling memorized one. Liu and colleagues (Omnigrok) pushed this further, arguing grokking is tied to the mismatch between the weight norm at initialization and the norm of good generalizing solutions, and that you can induce or suppress it by controlling that norm. Second — and this is the load-bearing part — the transition was invisible in the metric everyone watches. Train and test accuracy told you nothing was happening while the representation was being rebuilt. The interesting dynamics were orthogonal to the dashboard.
Double descent: bigger, past the point where bigger should hurt
Grokking bends the time axis. Double descent bends the capacity axis, and it is arguably the more foundational of the two because it directly overwrites the U-curve.
Belkin and colleagues named it in 2019; Nakkiran and colleagues documented it at scale in deep networks the same year. Sweep model size from small to large and plot test error. At first you get the classical U: error falls, then rises as the model gets flexible enough to chase noise. The rise peaks at a specific place — the interpolation threshold, where the model has just barely enough capacity to fit the training data exactly, driving training error to zero. In the classical story that peak is the end of the road; beyond it you are strictly overfitting.
Beyond it, test error goes down again. In the overparameterized regime — many more parameters than the model needs to interpolate — generalization improves, frequently past the best point the U-curve ever reached. The curve is not a U. It descends, ascends to a spike at interpolation, and descends a second time. Hence: double descent.
Concretely, imagine 4,000 training examples. A model whose effective capacity lets it just fit those 4,000 points sits on the worst part of the curve — the spike. The naive fix suggested by the U is to shrink the model back toward the sweet spot. Double descent says you can instead grow it — to ten times the parameters needed to interpolate — and land at lower test error than either. "Add capacity to a model that already fits the data perfectly, and it will generalize better" is a sentence the classical theory cannot produce, and it is routinely true.
The intuition for why is the useful part. Past the interpolation threshold there are infinitely many parameter settings that fit the training data exactly. They are not equally good on unseen data. What breaks the tie is the optimizer's inductive bias: gradient descent, from small initialization, tends to find low-norm, "smooth" interpolating solutions rather than jagged ones. Near the threshold the model is starved — there is essentially one way to fit the data, and it is forced to be a contorted one that fits the noise rigidly. Give it room, and the space of exact fits becomes large enough to contain gentle ones, and the optimizer's preference for those kicks in. Capacity stops being a liability and becomes the freedom to choose a better interpolant.
Double descent is not confined to model size. Nakkiran showed it appears along the training-time axis too — epoch-wise double descent, where test error falls, rises, and falls again as you simply keep training a fixed model. Stated that way, the kinship to grokking is hard to miss: a delayed second descent in test error as training continues past the point of apparent overfitting. Whether they are the same phenomenon in different clothing is genuinely unsettled, and I flag that as my read rather than an established result — but the shared shape is suggestive. Both look like a transition from a memorizing regime to a generalizing one, gated by some effective complexity that the loss curve does not display.
Why this is a theory problem, not a tuning problem
It would be comfortable to file these as tricks — use weight decay, overparameterize, train longer. That understates what they cost us. They are not just techniques; they are counterexamples to the theory that was supposed to tell us when techniques work.
Here is the tension, folk rule against reality:
| Classical rule | What actually happens |
|---|---|
| Bigger models overfit more | Past interpolation, bigger models often generalize better (double descent) |
| Fitting training data exactly is bad | Interpolating models can be near-optimal on test data |
| If it memorized, it won't generalize | It can generalize thousands of steps later (grokking) |
| Early stopping near zero train error is safe | The best generalization may be far past that point |
| Capacity bounds predict generalization | Networks fit random labels; the bounds are vacuous |
We do have partial explanations, and honesty requires naming them as partial. Implicit regularization — the optimizer's bias toward low-norm or otherwise simple interpolants — is real and does genuine work for double descent. Feature-learning accounts describe how representations sharpen over training. Mechanistic interpretability gives us, for the modular-arithmetic case, an actual circuit and an actual algorithm, which is as concrete as explanation gets. Weight decay's role in grokking is well established. What we do not have is a single theory that takes a network, a dataset, and a training budget and predicts whether generalization will appear, when, and how sharply. Each explanation illuminates a case. None of them is the U-curve's replacement, and pretending otherwise would be the same overconfidence in a new costume.
The actionable part: distrust the extrapolation
If small-scale training intuition is unreliable about its own regime, it is more unreliable about regimes it has never seen — and that has a direct consequence for how you should read scaling arguments. When a loss-versus-compute curve is smooth over the range you have measured, the temptation is to treat the curve as a law and read the future off its continuation. Grokking and double descent are the standing counterexample to that move: they are cases where behavior changes qualitatively — a phase-change-like jump in test accuracy, a non-monotonic error curve — with no warning in the metric you were plotting. A smooth curve is evidence about the interval you measured and a hypothesis about everything else. That is exactly the gap I argue scaling curves cannot close on their own: extrapolating a fit is not the same as understanding the mechanism that produced it, and without the mechanism you cannot know whether the next order of magnitude bends.
It also sharpens how to read claims of sudden new capabilities. Part of the debate over whether emergent abilities are real or a measurement artifact turns on the difference between a genuine reorganization and a discontinuous metric laid over continuous underlying change. Grokking is the clean, controlled case where a real internal reorganization is genuinely occurring and is genuinely invisible on accuracy until it isn't — which means both readings can be true in different cases, and the only way to tell them apart is to look inside, not to squint harder at the curve. That is precisely why mechanistic interpretability is not a side quest.
The concrete discipline: hold your generalization beliefs empirically, not theoretically, in this regime. Do not stop training the moment train error hits zero and call it overfit — check whether a later descent is coming. Do not assume a model too large for your data will overfit — the overparameterized side may be where you want to be. Do not extrapolate a capability curve past where you measured it and present the extension as knowledge. The theory that would justify those shortcuts is the theory we do not have.
We can build systems that generalize better than our best account of generalization says they should. That gap is not a rounding error to be tidied up later. It is the open problem sitting under everything else we are doing.